def director_field_vectorized(self, k, x, jac=False):
        """ Returns the value of the vector field for a nonlinear class at a given point.

        args:
            k (int) : indexes which nonlinear class
            x (numpy.array) :  (2,N)
        
        kwargs:
            jac: If True then returns the Jacobian of the vector-field too.

        returns:
            out1: ndarray (2,N)
            out2: ndarray (2,2,N) if jac==True
        """
        from numpy.polynomial.legendre import legval2d, legder
        theta = legval2d(x[0] / self.width, x[1] / self.height,
                         self.theta_coeffs[k])
        out1 = np.array([np.cos(theta), np.sin(theta)])
        if jac:
            dtheta_dx = legval2d(x[0] / self.width, x[1] / self.height,
                                 legder(self.theta_coeffs[k],
                                        axis=0)) / self.width
            dtheta_dy = legval2d(x[0] / self.width, x[1] / self.height,
                                 legder(self.theta_coeffs[k],
                                        axis=1)) / self.height
            N = x.shape[1]
            out2 = np.zeros((2, 2, N))
            out2[0, 0, :] = -out1[1] * dtheta_dx
            out2[0, 1, :] = -out1[1] * dtheta_dy
            out2[1, 0, :] = out1[0] * dtheta_dx
            out2[1, 1, :] = out1[0] * dtheta_dy
            return out1, out2
        return out1
    def director_field(self, k, x, jac=False):
        """ Returns the value of the vector field for a nonlinear class.

        args:
            x: ndarray (2,)
            k: int
        
        kwargs:
            jac: If True then returns the Jacobian of the vector-field too.

        returns:
            out1: ndarray (2,)
            out2: ndarray (2,2) if jac==True
        """
        from numpy.polynomial.legendre import legval2d, legder
        theta = legval2d(x[0] / self.width, x[1] / self.height,
                         self.theta_coeffs[k])
        #NOTE:  Yes, I know this scaling seems off by a factor of 2.  At the moment, this is correct. However, this should be refactored so that we use a scaling convention that is consistent with the rest of the code-base (e.g. posteriors.x_given_k
        out1 = np.array([np.cos(theta), np.sin(theta)])
        if jac:
            dtheta_dx = legval2d(x[0] / self.width, x[1] / self.height,
                                 legder(self.theta_coeffs[k],
                                        axis=0)) / self.width
            dtheta_dy = legval2d(x[0] / self.width, x[1] / self.height,
                                 legder(self.theta_coeffs[k],
                                        axis=1)) / self.height
            out2 = np.zeros((2, 2))
            out2[0, 0] = -out1[1] * dtheta_dx
            out2[0, 1] = -out1[1] * dtheta_dy
            out2[1, 0] = out1[0] * dtheta_dx
            out2[1, 1] = out1[0] * dtheta_dy
            return out1, out2
        return out1
Beispiel #3
0
 def __gradient(self, point_grid: ndarray) -> (NUMPY_TYPE, NUMPY_TYPE):
     coeffs_of_grad_x = legder(self.__c.mat / self.__scale.mat, axis=0)
     coeffs_of_grad_y = legder(self.__c.mat / self.__scale.mat, axis=1)
     sqrt_p = legval2d(*point_grid, self.__c.mat/self.__scale.mat)
     factor = 2.0 * self.__controller.N
     grad_x = factor * sqrt_p * legval2d(*point_grid, coeffs_of_grad_x)
     grad_y = factor * sqrt_p * legval2d(*point_grid, coeffs_of_grad_y)
     return self.__map.out(grad_x), self.__map.out(grad_y)
Beispiel #4
0
def hamiltonian(coefs, func=BASIS_FUNC, V=V, C=C):
    '''hamiltonian operator acting on wavefunction'''
    if func == 'legendre':
        ham = -C * L.legder(L.legder(coefs)) + V * L.Legendre(coefs)
        return ham
    elif func == 'fourier':
        ham = [V] + [(i**2) * C * coefs[i] for i in range(1, len(coefs))]
        return ham
Beispiel #5
0
    def parallels_transitions(turbine,
                              joints_parallel,
                              joints_vel_parallel,
                              joints_acc_parallel,
                              times_parallel,
                              step=.1,
                              number_of_points=8.):
        """ Given all parallels solutions, i.e., joints solutions for all waypoints split in parallels (lists),
        this method computes cubic polynomials to interpolate the two points: end of a parallel - begin of the next
        parallel, in joint space, considering velocities. It will return the parallels and the computed transition
        paths between them.
        Obs.: This is taking too long. No improvements are being made since plates can be used on the transition part.
        Args:
            turbine: (@ref Turbine) turbine object
            joints_parallel: (float[m][n<SUB>i</SUB>][nDOF]) list of joints for all parallels
            times_parallel: (float[m][n<SUB>i</SUB>]) list of deltatimes for all parallels
            step: distance (meters) between points
            number_of_points: minimal number of points
            max_acc: maximum permitted acceleration (percentage)
        Returns:
            Modifies the current joints_parallel and times_parallel with the computed transitions.
        """

        robot = turbine.robot

        for i in range(len(joints_parallel) - 1):
            joint_0 = joints_parallel[2 * i][-1]
            vel_0 = joints_vel_parallel[2 * i][-1]
            joint_1 = joints_parallel[2 * i + 1][0]
            vel_1 = joints_vel_parallel[2 * i + 1][0]

            c = mathtools.legn_path(3, [joint_0, joint_1], [vel_0, vel_1])
            joints = []
            joints_vel = []
            joints_acc = []
            times = []
            dt = min([step, 1. / number_of_points])
            for t in linspace(0, 1., max([1. / step, number_of_points])):
                joints.append(legendre.legval(t, c))
                joints_vel.append(legendre.legval(t, legendre.legder(c, 1)))
                joints_acc.append(legendre.legval(t, legendre.legder(c, 2)))
                times.append(dt)

            joints = joints[1:-1]
            joints_vel = joints_vel[1:-1]
            joints_acc = joints_acc[1:-1]
            times_parallel[2 * i + 1][0] = times[-1]
            times = times[1:-1]

            joints_parallel.insert(2 * i + 1, joints)
            joints_vel_parallel.insert(2 * i + 1, joints_vel)
            joints_acc_parallel.insert(2 * i + 1, joints_acc)
            times_parallel.insert(2 * i + 1, times)

        return joints_parallel, joints_vel_parallel, joints_acc_parallel, times_parallel
Beispiel #6
0
    def test_legder_axis(self):
        # check that axis keyword works
        c2d = np.random.random((3, 4))

        tgt = np.vstack([leg.legder(c) for c in c2d.T]).T
        res = leg.legder(c2d, axis=0)
        assert_almost_equal(res, tgt)

        tgt = np.vstack([leg.legder(c) for c in c2d])
        res = leg.legder(c2d, axis=1)
        assert_almost_equal(res, tgt)
Beispiel #7
0
    def test_legder_axis(self):
        # check that axis keyword works
        c2d = np.random.random((3, 4))

        tgt = np.vstack([leg.legder(c) for c in c2d.T]).T
        res = leg.legder(c2d, axis=0)
        assert_almost_equal(res, tgt)

        tgt = np.vstack([leg.legder(c) for c in c2d])
        res = leg.legder(c2d, axis=1)
        assert_almost_equal(res, tgt)
Beispiel #8
0
    def make_grid(self):
        import numpy as np
        from numpy.polynomial.legendre import legder, legroots, legval

        N = self._N
        self.NN = N + 1
        L = self.L

        factor = L / 2

        d1 = np.zeros((N + 1, N + 1))

        cp = legder([0] * N + [1])
        zg = np.hstack([-1.0, legroots(cp), 1.0])

        P_N = legval(zg, [0] * N + [1])

        with np.errstate(divide='ignore'):
            d1 = P_N[:, None] / (P_N[None, :] * (zg[:, None] - zg[None, :]))

        d1[np.diag_indices(N + 1)] = 0.0
        d1[0, 0] = -N * (N + 1) / 4
        d1[N, N] = +N * (N + 1) / 4

        d2 = np.dot(d1, d1)

        self.zg = (zg + 1) * L / 2 + self.zmin
        self.d0 = np.eye(self.NN)
        self.d1 = d1 / factor
        self.d2 = d2 / factor**2

        # Call other objects that depend on the grid
        for callback in self._observers:
            callback()
def Stormer_Verlet(x0, y0, x1, y1, n_steps, theta, V_scale, Delta_t=1.0):
    from numpy.polynomial.legendre import legder,legval2d
    theta_x = legder( theta, axis=0, m=1)
    theta_y = legder( theta, axis=1, m=1)
    x_pred = np.zeros(n_steps)
    y_pred = np.zeros(n_steps)
    x_pred[0],x_pred[1] = (x0,x1)
    y_pred[0],y_pred[1] = (y0,y1)    
    for k in range(n_steps-2):
        x1,y1 = (x_pred[k+1],y_pred[k+1])
        x0,y0 = (x_pred[k],y_pred[k])
        V_x = legval2d( x1/V_scale[0], y1/V_scale[1], theta_x )/V_scale[0]
        V_y = legval2d( x1/V_scale[0], y1/V_scale[1], theta_y )/V_scale[1]
        x_pred[k+2] = 2*x1 - x0 - Delta_t**2 * V_x
        y_pred[k+2] = 2*y1 - y0 - Delta_t**2 * V_y
    return x_pred, y_pred
def Stormer_Verlet(x0, y0, x1, y1, n_steps, theta, V_scale, Delta_t=1.0):
    from numpy.polynomial.legendre import legder, legval2d
    theta_x = legder(theta, axis=0, m=1)
    theta_y = legder(theta, axis=1, m=1)
    x_pred = np.zeros(n_steps)
    y_pred = np.zeros(n_steps)
    x_pred[0], x_pred[1] = (x0, x1)
    y_pred[0], y_pred[1] = (y0, y1)
    for k in range(n_steps - 2):
        x1, y1 = (x_pred[k + 1], y_pred[k + 1])
        x0, y0 = (x_pred[k], y_pred[k])
        V_x = legval2d(x1 / V_scale[0], y1 / V_scale[1], theta_x) / V_scale[0]
        V_y = legval2d(x1 / V_scale[0], y1 / V_scale[1], theta_y) / V_scale[1]
        x_pred[k + 2] = 2 * x1 - x0 - Delta_t**2 * V_x
        y_pred[k + 2] = 2 * y1 - y0 - Delta_t**2 * V_y
    return x_pred, y_pred
    def _getNodes(self):
        """
        Computes Gauss-Lobatto integration nodes.

        Calculates the Gauss-Lobatto integration nodes via a root calculation of derivatives of the legendre
        polynomials. Note that the precision of float 64 is not guarantied.

        Copyright by Dieter Moser, 2014

        Returns:
            np.ndarray: array of Gauss-Lobatto nodes
        """

        M = self.num_nodes
        a = self.tleft
        b = self.tright

        roots = leg.legroots(
            leg.legder(np.array([0] * (M - 1) + [1], dtype=np.float64)))
        nodes = np.array(np.append([-1.0], np.append(roots, [1.0])),
                         dtype=np.float64)

        nodes = (a * (1 - nodes) + b * (1 + nodes)) / 2

        return nodes
Beispiel #12
0
def quad_custom(fun, n=10):
    P_n = [0 for i in range(1, n)] + [1]
    P_n_roots = leg.legroots(P_n)
    d_P_n = leg.legder(P_n)
    d_P_n_vals = leg.legval(P_n_roots, d_P_n)
    weights = 2 / ((1 - np.power(P_n_roots, 2)) * np.power(d_P_n_vals, 2))
    result = np.sum(weights * fun(P_n_roots))
    return result
Beispiel #13
0
def gaussian_latitudes(n):
    """Construct latitudes and latitude bounds for a Gaussian grid.
    
    Args:
    
    * n:
        The Gaussian grid number (half the number of latitudes in the
        grid.

    Returns:
        A 2-tuple where the first element is a length `n` array of
        latitudes (in degrees) and the second element is an `(n, 2)`
        array of bounds.

    """
    if abs(int(n)) != n:
        raise ValueError('n must be a non-negative integer')
    nlat = 2 * n
    # Create the coefficients of the Legendre polynomial and construct the
    # companion matrix:
    cs = np.array([0] * nlat + [1], dtype=np.int)
    cm = legcompanion(cs)
    # Compute the eigenvalues of the companion matrix (the roots of the
    # Legendre polynomial) taking advantage of the fact that the matrix is
    # symmetric:
    roots = la.eigvalsh(cm)
    roots.sort()
    # Improve the roots by one application of Newton's method, using the
    # solved root as the initial guess:
    fx = legval(roots, cs)
    fpx = legval(roots, legder(cs))
    roots -= fx / fpx
    # The roots should exhibit symmetry, but with a sign change, so make sure
    # this is the case:
    roots = (roots - roots[::-1]) / 2.
    # Compute the Gaussian weights for each interval:
    fm = legval(roots, cs[1:])
    fm /= np.abs(fm).max()
    fpx /= np.abs(fpx).max()
    weights = 1. / (fm * fpx)
    # Weights should be symmetric and sum to two (unit weighting over the
    # interval [-1, 1]):
    weights = (weights + weights[::-1]) / 2.
    weights *= 2. / weights.sum()
    # Calculate the bounds from the weights, still on the interval [-1, 1]:
    bounds1d = np.empty([nlat + 1])
    bounds1d[0] = -1
    bounds1d[1:-1] = -1 + weights[:-1].cumsum()
    bounds1d[-1] = 1
    # Convert the bounds to degrees of latitude on [-90, 90]:
    bounds1d = np.rad2deg(np.arcsin(bounds1d))
    bounds2d = np.empty([nlat, 2])
    bounds2d[:, 0] = bounds1d[:-1]
    bounds2d[:, 1] = bounds1d[1:]
    # Convert the roots from the interval [-1, 1] to latitude values on the
    # interval [-90, 90] degrees:
    latitudes = np.rad2deg(np.arcsin(roots))
    return latitudes, bounds2d
Beispiel #14
0
def gaussian_latitudes(n):
    """Construct latitudes and latitude bounds for a Gaussian grid.

    Args:

    * n:
        The Gaussian grid number (half the number of latitudes in the
        grid.

    Returns:
        A 2-tuple where the first element is a length `n` array of
        latitudes (in degrees) and the second element is an `(n, 2)`
        array of bounds.

    """
    if abs(int(n)) != n:
        raise ValueError('n must be a non-negative integer')
    nlat = 2 * n
    # Create the coefficients of the Legendre polynomial and construct the
    # companion matrix:
    cs = np.array([0] * nlat + [1], dtype=np.int)
    cm = legcompanion(cs)
    # Compute the eigenvalues of the companion matrix (the roots of the
    # Legendre polynomial) taking advantage of the fact that the matrix is
    # symmetric:
    roots = la.eigvalsh(cm)
    roots.sort()
    # Improve the roots by one application of Newton's method, using the
    # solved root as the initial guess:
    fx = legval(roots, cs)
    fpx = legval(roots, legder(cs))
    roots -= fx / fpx
    # The roots should exhibit symmetry, but with a sign change, so make sure
    # this is the case:
    roots = (roots - roots[::-1]) / 2.
    # Compute the Gaussian weights for each interval:
    fm = legval(roots, cs[1:])
    fm /= np.abs(fm).max()
    fpx /= np.abs(fpx).max()
    weights = 1. / (fm * fpx)
    # Weights should be symmetric and sum to two (unit weighting over the
    # interval [-1, 1]):
    weights = (weights + weights[::-1]) / 2.
    weights *= 2. / weights.sum()
    # Calculate the bounds from the weights, still on the interval [-1, 1]:
    bounds1d = np.empty([nlat + 1])
    bounds1d[0] = -1
    bounds1d[1:-1] = -1 + weights[:-1].cumsum()
    bounds1d[-1] = 1
    # Convert the bounds to degrees of latitude on [-90, 90]:
    bounds1d = np.rad2deg(np.arcsin(bounds1d))
    bounds2d = np.empty([nlat, 2])
    bounds2d[:, 0] = bounds1d[:-1]
    bounds2d[:, 1] = bounds1d[1:]
    # Convert the roots from the interval [-1, 1] to latitude values on the
    # interval [-90, 90] degrees:
    latitudes = np.rad2deg(np.arcsin(roots))
    return latitudes, bounds2d
Beispiel #15
0
 def apply_H_legendre(self):
     '''This applies the Hamiltonian operator, utilizing a builtin capability of the numpy.polynomial.legendre module to get the second derivatives. Note that we have to "pad" the coefficients array with two zeros after taking the second derivative.'''
     #taking del^2 has never been easier!
     new_coefficients = L.legder(self.coefficients, 2)
     new_coefficients = list(new_coefficients)
     for i in range(2):
         new_coefficients.append(0)
     new_coefficients = np.array(new_coefficients)  #what a pain!
     return (np.array(new_coefficients * (-self.c) +
                      self.v * self.coefficients * self.period))
Beispiel #16
0
 def evaluate_basis_derivative(self, x=None, i=0, k=0, output_array=None):
     if x is None:
         x = self.mesh(False, False)
     x = np.atleast_1d(x)
     v = self.evaluate_basis(x, i, output_array)
     if k > 0:
         D = np.zeros((self.N, self.N))
         D[:-k, :] = leg.legder(np.eye(self.N), k)
         v = np.dot(v, D)
     return v
Beispiel #17
0
    def test_legcubic_path(self):
        def asin(x):
            A = 2
            w = pi / 4
            return A * sin(w * x)

        def dasin(x):
            A = 2
            w = pi / 4
            return A * w * cos(w * x)

        def e(x):
            return exp(x) - 1

        def de(x):
            return exp(x)

        p1 = array([asin(0), e(0)])
        p2 = array([asin(1), e(1)])
        dp1 = array([dasin(0), de(0)])
        dp2 = array([dasin(1), de(1)])

        c = mathtools.legcubic_path(p1, p2, dp1, dp2)
        legsol1 = legendre.legval(0, c)
        for i in range(len(p1)):
            self.assertAlmostEqual(legsol1[i], p1[i])

        legsol2 = legendre.legval(1, c)
        for i in range(len(p2)):
            self.assertAlmostEqual(legsol2[i], p2[i])

        legdsol1 = legendre.legval(0, legendre.legder(c))
        for i in range(len(dp1)):
            self.assertAlmostEqual(legdsol1[i], dp1[i])

        legdsol2 = legendre.legval(1, legendre.legder(c))
        for i in range(len(dp2)):
            self.assertAlmostEqual(legdsol2[i], dp2[i])

        self.assertEquals(legsol1.shape, p1.shape)
        self.assertEquals(legsol2.shape, p2.shape)
        self.assertEquals(legdsol1.shape, dp1.shape)
        self.assertEquals(legdsol2.shape, dp2.shape)
Beispiel #18
0
 def evaluate_basis_derivative_all(self, x=None, k=0):
     if x is None:
         x = self.mesh(False, False)
     V = self.vandermonde(x)
     #assert self.N == V.shape[1]
     M = V.shape[1]
     if k > 0:
         D = np.zeros((M, M))
         D[:-k, :] = leg.legder(np.eye(M), k)
         V = np.dot(V, D)
     return self._composite_basis(V)
Beispiel #19
0
    def _compute_nodes(self):
        """Computes Gauss-Lobatto integration nodes.

        Calculates the Gauss-Lobatto integration nodes via a root calculation of derivatives of the legendre
        polynomials.
        Note that the precision of float 64 is not guarantied.
        """
        roots = leg.legroots(leg.legder(np.array([0] * (self.num_nodes - 1) +
                                                 [1], dtype=np.float64)))
        self._nodes = np.array(np.append([-1.0], np.append(roots, [1.0])),
                               dtype=np.float64)
Beispiel #20
0
def legReconstructDerivative(freqs, locations, spectrum, numPts):
    """

    :param freqs:
    :param locations:
    :param spectrum:
    :param numPts:
    :return: derivative of iFFT of the spectrum as an array with shape (Npts, Ncomponent) or (Ncomponent,) if 1-d
    """
    deriv=leg.legder(spectrum, axis=0)
    return genericLegVal(locations, deriv)
Beispiel #21
0
 def evaluate_basis_derivative_all(self, x=None, k=0, argument=0):
     if x is None:
         x = self.mesh(False, False)
     V = self.vandermonde(x)
     #assert self.N == V.shape[1]
     N, M = self.shape(False), self.shape(True)
     if k > 0:
         D = np.zeros((M, N))
         D[:-k] = leg.legder(np.eye(M, N), k)
         V = np.dot(V, D)
     return self._composite_basis(V, argument=argument)
Beispiel #22
0
    def director_field_vectorized(self, k, x, jac=False):
        """ Returns the value of the vector field for a nonlinear class at a given point.

        args:
            k (int) : indexes which nonlinear class
            x (numpy.array) :  (2,N)
        
        kwargs:
            jac: If True then returns the Jacobian of the vector-field too.

        returns:
            out1: ndarray (2,N)
            out2: ndarray (2,2,N) if jac==True
        """
        from numpy.polynomial.legendre import legval2d, legder
        theta = legval2d(
                x[0]/self.width,
                x[1]/self.height,
                self.theta_coeffs[k]
                )
        out1 = np.array([np.cos(theta), np.sin(theta)])
        if jac:
            dtheta_dx = legval2d(
                        x[0]/self.width,
                        x[1]/self.height,
                        legder( self.theta_coeffs[k], axis=0)
                        ) / self.width
            dtheta_dy = legval2d(
                        x[0]/self.width,
                        x[1]/self.height,
                        legder( self.theta_coeffs[k], axis=1)
                        ) / self.height
            N = x.shape[1]
            out2 = np.zeros((2,2,N))
            out2[0,0,:] = -out1[1]*dtheta_dx
            out2[0,1,:] = -out1[1]*dtheta_dy
            out2[1,0,:] = out1[0]*dtheta_dx
            out2[1,1,:] = out1[0]*dtheta_dy
            return out1, out2
        return out1
def GaussQuad(f, xi, xf, n, M):
    I = 0
    c = np.append(np.zeros(M), 1)
    x = lg.legroots(c)
    w = 0 * x
    d = lg.legder(c)
    for i in range(len(x)):
        w[i] = 2. / ((1 - x[i]**2) * (lg.legval(x[i], d))**2)
    for i in range(M):
        I += w[i] * f(n, interval(x[i], xf, xi))
    I *= 0.5 * (xf - xi)

    return I
Beispiel #24
0
    def director_field(self, k, x, jac=False ):
        """ Returns the value of the vector field for a nonlinear class.

        args:
            x: ndarray (2,)
            k: int
        
        kwargs:
            jac: If True then returns the Jacobian of the vector-field too.

        returns:
            out1: ndarray (2,)
            out2: ndarray (2,2) if jac==True
        """
        from numpy.polynomial.legendre import legval2d, legder
        theta = legval2d(
                x[0]/self.width,
                x[1]/self.height,
                self.theta_coeffs[k]
                )
        out1 = np.array([np.cos(theta), np.sin(theta)])
        if jac:
            dtheta_dx = legval2d(
                        x[0]/self.width,
                        x[1]/self.height,
                        legder( self.theta_coeffs[k], axis=0)
                        ) / self.width
            dtheta_dy = legval2d(
                        x[0]/self.width,
                        x[1]/self.height,
                        legder( self.theta_coeffs[k], axis=1)
                        ) / self.height
            out2 = np.zeros( (2,2) )
            out2[0,0] = - out1[1]*dtheta_dx
            out2[0,1] = - out1[1]*dtheta_dy
            out2[1,0] = out1[0]*dtheta_dx
            out2[1,1] = out1[0]*dtheta_dy
            return out1, out2
        return out1
Beispiel #25
0
def weights_roots(order, rules='Gauss-Lobatto'):
    c_leg = [1] if order == 0 else [i//order for i in xrange(order+1)]
    c_dleg = lgd.legder(c_leg)

    if rules == 'Gauss-Lobatto':
        xs = np.array( [-1] + list( lgd.legroots(c_dleg) ) + [1] )
        ws = 2 / ( order * (order + 1) * (lgd.legval(xs, c_leg)**2) )

    elif rules == 'Gauss-Legendre':
        xs = lgd.legroots(c_leg)
        ws = 2 / ( (1 - xs**2) * (lgd.legval(xs, c_dleg)**2) )

    return xs, ws
Beispiel #26
0
def Hamiltonian_Legendre_polynomial(c, potential, domain, N):
    #potential is a constant in this case

    x = np.linspace(-domain / 2, domain / 2, N)
    delta_x = domain / (N - 1)

    #here, the normalized legendre polynomical has been used
    # for the nth polynomials, normalization constant is sqrt(2/(2n + 1))

    #kinetic term
    K = np.zeros((N, N))

    for ii in range(N):
        legen_left = np.zeros(N)
        legen_left[ii] = mt.sqrt((2 * ii + 1) / 2)
        for jj in range(N):
            deriva_array = np.zeros(N + 2)
            deriva_array[jj] = mt.sqrt((2 * jj + 1) / 2)
            legen_right_deriva = legen.legder(deriva_array, 2)

            #multiply them
            legen_multiply = legen.legmul(legen_left, legen_right_deriva)

            #integral
            legen_integral = legen.legint(legen_multiply)

            #calculate the matrix elements
            K[ii][jj] = legen.legval(domain / 2, legen_integral) - \
                        legen.legval(-domain / 2, legen_integral)

    #the S matrix, inside the [-1, 1] domain, the legendre ploynomial can be treatedas basis and satisfying <xi|xj> = delta ij, thus S matrix is a identity matrix
    S = np.zeros((N, N))

    for ii in range(N):
        legen_left_S = np.zeros(N)
        legen_left_S[ii] = mt.sqrt((2 * ii + 1) / 2)
        legen_multiply_S = legen.legmul(legen_left_S, legen_left_S)
        legen_integral_S = legen.legint(legen_multiply_S)
        S[ii][ii] = legen.legval(domain / 2, legen_integral_S) - \
                    legen.legval(-domain / 2, legen_integral_S)

    K = K * -1 * c

    #because the potential is just a constant here, we can calculate the V matrix   simply by multiply the matrix S a constant potential value

    V = potential * S

    ##divide the obtained Hamiltonian by the S matrix
    H = K + V
    return H
def jac_ode_function( xy, t, alpha, width, height, speed=1.0 ):
    """ returns velocity feild for input into odeint

    args:
        xy (np.ndarray) : shape = (2,)
        t (float):
        alpha: coefficients for angles

    returns:
        out (np.ndarray) : jacobian of velocity field, shape = (2,2)
    """
    x = xy[0]
    y = xy[1]
    theta = legval2d( x / width, y / height, alpha )
    theta_x = legval2d( x / width, y / height, legder( alpha, axis=0) ) / width
    theta_y = legval2d( x / width, y / height, legder( alpha, axis=1) ) / height
    out = np.zeros( (2,2) )
    out[0,0] = - np.sin(theta)*theta_x
    out[0,1] = - np.sin(theta)*theta_y
    out[1,0] = np.cos(theta)*theta_x
    out[1,1] = np.cos(theta)*theta_y
    out *= speed
    return out
def jac_ode_function(xy, t, alpha, width, height, speed=1.0):
    """ returns velocity feild for input into odeint

    args:
        xy (np.ndarray) : shape = (2,)
        t (float):
        alpha: coefficients for angles

    returns:
        out (np.ndarray) : jacobian of velocity field, shape = (2,2)
    """
    x = xy[0]
    y = xy[1]
    theta = legval2d(x / width, y / height, alpha)
    theta_x = legval2d(x / width, y / height, legder(alpha, axis=0)) / width
    theta_y = legval2d(x / width, y / height, legder(alpha, axis=1)) / height
    out = np.zeros((2, 2))
    out[0, 0] = -np.sin(theta) * theta_x
    out[0, 1] = -np.sin(theta) * theta_y
    out[1, 0] = np.cos(theta) * theta_x
    out[1, 1] = np.cos(theta) * theta_y
    out *= speed
    return out
Beispiel #29
0
    def test_legder(self) :
        # check exceptions
        assert_raises(ValueError, leg.legder, [0], .5)
        assert_raises(ValueError, leg.legder, [0], -1)

        # check that zeroth deriviative does nothing
        for i in range(5) :
            tgt = [0]*i + [1]
            res = leg.legder(tgt, m=0)
            assert_equal(trim(res), trim(tgt))

        # check that derivation is the inverse of integration
        for i in range(5) :
            for j in range(2, 5) :
                tgt = [0]*i + [1]
                res = leg.legder(leg.legint(tgt, m=j), m=j)
                assert_almost_equal(trim(res), trim(tgt))

        # check derivation with scaling
        for i in range(5) :
            for j in range(2, 5) :
                tgt = [0]*i + [1]
                res = leg.legder(leg.legint(tgt, m=j, scl=2), m=j, scl=.5)
                assert_almost_equal(trim(res), trim(tgt))
Beispiel #30
0
    def test_legder(self) :
        # check exceptions
        assert_raises(ValueError, leg.legder, [0], .5)
        assert_raises(ValueError, leg.legder, [0], -1)

        # check that zeroth deriviative does nothing
        for i in range(5) :
            tgt = [0]*i + [1]
            res = leg.legder(tgt, m=0)
            assert_equal(trim(res), trim(tgt))

        # check that derivation is the inverse of integration
        for i in range(5) :
            for j in range(2,5) :
                tgt = [0]*i + [1]
                res = leg.legder(leg.legint(tgt, m=j), m=j)
                assert_almost_equal(trim(res), trim(tgt))

        # check derivation with scaling
        for i in range(5) :
            for j in range(2,5) :
                tgt = [0]*i + [1]
                res = leg.legder(leg.legint(tgt, m=j, scl=2), m=j, scl=.5)
                assert_almost_equal(trim(res), trim(tgt))
Beispiel #31
0
def gauss_lobatto_points(start, stop, num_points):
    r"""Get the node points for Gauss-Lobatto quadrature.

    Using :math:`n` points, this quadrature is accurate to degree
    :math:`2n - 3`. The node points are :math:`x_1 = -1`,
    :math:`x_n = 1` and the interior are :math:`n - 2` roots of
    :math:`P'_{n - 1}(x)`.

    Though we don't compute them here, the weights are
    :math:`w_1 = w_n = \frac{2}{n(n - 1)}` and for the interior points

    .. math::

       w_j = \frac{2}{n(n - 1) \left[P_{n - 1}\left(x_j\right)\right]^2}

    This is in contrast to the scheme used in Gaussian quadrature, which
    use roots of :math:`P_n(x)` as nodes and use the weights

    .. math::

       w_j = \frac{2}{\left(1 - x_j\right)^2
                \left[P'_n\left(x_j\right)\right]^2}

    .. note::

       This method is **not** generic enough to accommodate non-NumPy
       types as it relies on the :mod:`numpy.polynomial.legendre`.

    :type start: float
    :param start: The beginning of the interval.

    :type stop: float
    :param stop: The end of the interval.

    :type num_points: int
    :param num_points: The number of points to use.

    :rtype: :class:`numpy.ndarray`
    :returns: 1D array, the interior quadrature nodes.
    """
    p_n_minus1 = [0] * (num_points - 1) + [1]
    inner_nodes = legendre.legroots(legendre.legder(p_n_minus1))
    # Utilize symmetry about 0.
    inner_nodes = 0.5 * (inner_nodes - inner_nodes[::-1])
    if start != -1.0 or stop != 1.0:
        # [-1, 1] --> [0, 2] --> [0, stop - start] --> [start, stop]
        inner_nodes = start + (inner_nodes + 1.0) * 0.5 * (stop - start)
    return np.hstack([[start], inner_nodes, [stop]])
Beispiel #32
0
def Legendre_polynomial_basis(c, potential, domain, N, wave_func):

    x = np.linspace(-domain / 2, domain / 2, N)

    #represent out wave function in the legendre polynomial basis
    wave_legen = legen.legfit(x, wave_func, N)

    #calculate H |bj>, where H = -c Lap + V

    #calculate -c Lap |bj>
    Hbj_first = -1 * c * legen.legder(wave_legen, 2)
    #calculate V|bj>, here, V is a constant
    Hbj_secod = potential * wave_legen
    Hbj = Hbj_first + Hbj_secod[0:N - 1]

    return Hbj
Beispiel #33
0
    def get_vandermonde_basis_derivative(self, V, k=0):
        """Return k'th derivatives of basis as a Vandermonde matrix

        Parameters
        ----------
            V : array of ndim = 2
                Chebyshev Vandermonde matrix
            k : int
                k'th derivative
        """
        assert self.N == V.shape[1]
        if k > 0:
            D = np.zeros((self.N, self.N))
            D[:-k, :] = leg.legder(np.eye(self.N), k)
            V = np.dot(V, D)

        return self.get_vandermonde_basis(V)
Beispiel #34
0
def add_plot(X, lbl, clr, type='o'):
    Peq = pos_equilibrium(X)
    n = Peq.size
    for i in range(n):
        plt.plot(Peq[i, 0], 0, type, color=clr)

    c = [0] * (n + 2)
    c[n + 1] = 1

    d = L.legder(c)
    P = L.leg2poly(d)

    P = mirror(P)
    Poly = np.poly1d(P)
    x = np.linspace(-1, 1, 100)
    y = Poly(x)
    plt.plot(x, y, label=lbl, color=clr)
Beispiel #35
0
def add_plot(X, lbl, clr, type='o'):
    Peq = Newton_Raphson(grad_E, Jacobian_E, X, 100, 1e-8)
    n = Peq.size
    for i in range(n):
        plt.plot(Peq[i, 0], 0, type, color=clr)

    c = [0] * (n + 2)
    c[n + 1] = 1

    d = L.legder(c)
    P = L.leg2poly(d)

    P = mirror(P)
    Poly = np.poly1d(P)
    x = np.linspace(-1, 1, 100)
    y = Poly(x)
    plt.plot(x, y, label=lbl, color=clr)
    def _getNodes(self):
        """
        Copyright by Dieter Moser, 2014
        Computes Gauss-Lobatto integration nodes.

        Calculates the Gauss-Lobatto integration nodes via a root calculation of derivatives of the legendre
        polynomials. Note that the precision of float 64 is not guarantied.
        """
        M = self.num_nodes
        a = self.tleft
        b = self.tright

        roots = leg.legroots(leg.legder(np.array([0] * (M - 1) + [1], dtype=np.float64)))
        nodes = np.array(np.append([-1.0], np.append(roots, [1.0])), dtype=np.float64)

        nodes = (a * (1 - nodes) + b * (1 + nodes)) / 2

        return nodes
Beispiel #37
0
    def __accel__(t, vi, deg=[0]):
        """Equation for acceleration due to gravity.

        :t: current time
        :vi: current position and velocity vector
        :n: degrees of perturbation terms to use ([0] = 2-body)

        """
        from numpy.polynomial.legendre import legval, legder

        # initialize solution vector
        v = np.zeros(len(vi))

        # dr/dt = v
        v[:3] = vi[3:]

        # magnitude of position vector
        r = norm(vi[:3])

        # sin(phi) = z/r
        sinphi = vi[2] / r

        xi = re / r

        # Common coefficients for Legendre polynomials and derivatives
        mult = [J[n] * xi**n if n in deg else 0 for n in xrange(max(deg) + 1)]

        # compute coefficients for Legendre polynomial evaluation
        cPn = (np.arange(max(deg) + 1) + 1) * mult

        # Legendre summation
        Pn = legval(sinphi, cPn)

        # Legendre derivative summation
        Pn_prime = legval(sinphi, legder(mult))

        # common acceleration
        v[3:] = (mu / r**3) * (Pn + sinphi * Pn_prime) * vi[:3]

        # additive term for z-acceleration
        v[-1] -= (mu / r**3) * (r * Pn_prime)

        return v
Beispiel #38
0
def calculate_roots(deg):
    rez = []
    for i in range(1, deg // 2 + deg % 2 + 1):
        x_0 = math.cos(math.pi * (4 * i - 1) / (4 * deg + 2))
        x_k = x_0
        coefs = np.zeros(i)
        coefs[i - 1] = 1
        der_coefs = legndr.legder(coefs)
        x_k_1 = x_k - legndr.legval([x_k], coefs)[0] / legndr.legval(
            [x_k], der_coefs)[0]
        e = 2 / (deg * 10)

        while x_k_1 - x_k > e:
            temp = x_k_1
            x_k_1 = x_k - legndr.legval([x_k], coefs)[0] / legndr.legval(
                [x_k], der_coefs)[0]
            x_k = temp

        rez.append(x_k)
    return rez
Beispiel #39
0
    def __init__(self, n, k, a, m):
        self.k2 = 2 * k

        # Uniform grid points
        x = np.linspace(-1, 1, n)

        # Legendre Polynomials on grid
        self.V = legvander(x, m - 1)

        # Do QR factorization of Vandermonde for least squares
        self.Q, self.R = qr(self.V, mode='economic')

        I = np.eye(m)
        D = np.zeros((m, m))
        D[:-self.k2, :] = legder(I, self.k2)

        # Legendre modal approximation of differential operator
        self.A = I - a * D

        # Store LU factors for repeated solves
        self.PLU = lu_factor(self.A[:-self.k2, self.k2:])
Beispiel #40
0
def weights(order):

    x = roots(order)
    w = np.empty(order)
    coef = []
    for n in range(0, order+1):
        if(n == order):
            coef.append(1)
        else:
            coef.append(0)

    derivative_coefficients = leg.legder(coef)
    del coef[-1]
    del coef[-1]
    coef.append(1)
    for i in range(0, order):
        tmp = leg.Legendre(derivative_coefficients, domain=[-1, 1])(2*x[i] - 1)
        tmp2 = leg.Legendre(coef, domain=[-1, 1])(2.0*x[i] - 1)
        w[i] = 1/(order*tmp*tmp2)
        # Possibly some bug here, get a factor 2 different using mathematica
    return w
Beispiel #41
0
def get_basis(deg, dofset=None):
    # Legendre polynomials are used as the basis of polynomials. In the basis of
    # Legendre polynomials is row of eye
    polyset = np.eye(deg+1)
   
    if dofset is None: dofset = np.linspace(-1, 1, deg+1)
    # Reatange dofs to have external first
    dofset = np.r_[dofset[0], dofset[-1], dofset[1:-1]]
    # Compute the nodal matrix
    A = np.array([legval(dofset, base) for base in polyset])
    # New coefficients
    B = np.linalg.inv(A) 

    # Combine the basis according to new weights
    basis = [lambda x, c=c: legval(x, c) for c in B]
    # Check that the basis is nodal
    assert np.allclose(np.array([f(dofset) for f in basis]), polyset)
    # First deriv
    dbasis = [lambda x, c=legder(c): legval(x, c) for c in B]
    
    return basis, dbasis
Beispiel #42
0
    def __init__(self,n,k,a,m):
        self.k2 = 2*k

        # Uniform grid points
        x = np.linspace(-1,1,n)

        # Legendre Polynomials on grid 
        self.V = legvander(x,m-1)

        # Do QR factorization of Vandermonde for least squares 
        self.Q,self.R = qr(self.V,mode='economic')

        I = np.eye(m)
        D = np.zeros((m,m))
        D[:-self.k2,:] = legder(I,self.k2)

        # Legendre modal approximation of differential operator
        self.A = I-a*D

        # Store LU factors for repeated solves   
        self.PLU = lu_factor(self.A[:-self.k2,self.k2:])
Beispiel #43
0
def legder(cs, m=1, scl=1) :
    from numpy.polynomial.legendre import legder
    return legder(cs, m, scl)
fl = lambdify(x, f, "numpy")
ul = lambdify(x, u, "numpy")

n = 32
domain = sys.argv[-1] if len(sys.argv) == 2 else "C1"

# Chebyshev-Gauss nodes and weights
points, w = leg.leggauss(n+1)

# Chebyshev Vandermonde matrix
V = leg.legvander(points, n)

scl=1.0
# First derivative matrix zero padded to (n+1)x(n+1)
D1 = np.zeros((n+1,n+1))
D1[:-1,:] = leg.legder(np.eye(n+1), 1, scl=scl)

Vx  = np.dot(V, D1)

# Matrix of trial functions
P = np.zeros((n+1,n+1))

P[:,0] = (V[:,0] - V[:,1])/2
P[:,1:-1] = V[:,:-2] - V[:,2:]
P[:,-1] = (V[:,0] + V[:,1])/2

# Matrix of first derivatives of trial functions
Px = np.zeros((n+1,n+1))
Px[:,0] = (Vx[:,0] - Vx[:,1])/2
Px[:,1:-1] = Vx[:,:-2] - Vx[:,2:]
Px[:,-1] = (Vx[:,0] + Vx[:,1])/2
Beispiel #45
0
from scipy.interpolate import interp1d

Nin = 10                                    # Number of data points in 
Nout = 50                                    # Number of points we want to project onto
Nfine = Nin**2                              # Number of points for plotting pretty 
Xin = np.linspace(-1,1,Nin)                 # The space of points
Fin = np.cos(20*Xin)+np.sin(7*Xin)          # Evaluate some fake data
Xfine = np.linspace(-1,1,Nfine)             # Linspace for plotting pretty
Fspline = interp1d(Xin,Fin,kind='cubic')    # A spline interpolation of the data
Xout = np.linspace(-1,1,Nout-1)             # Probably don't need this since we want to plot at the GLL nodes
I = np.eye(Nout)                            # A hack for choosing the right polynomial orders 
zero = np.zeros(Nout-1)


# Build our set of GLL nodes
pts = legendre.legroots(legendre.legder(I[-1])) # GLL points
Xi = [-1, list(pts), 1]
Xi = np.hstack(Xi)
#print "GLL Points:", Xi

# Build the weight set
weights = np.zeros([len(Xi)])
for i in range(len(Xi)-2):
    weights[i+1] = 2/((Nout)*(Nout-1)*(legendre.legval(Xi[i+1],I[-1]))**2)

weights[0]=2.0/((Nout)*(Nout-1))
weights[-1]=weights[0]
#print "GLL Weights:", weights

# Calculate the norms    
norms = np.zeros(Nout)