Ejemplo n.º 1
0
def JacobiGQ(alpha, beta, N):
    """Compute the N'th order Gauss quadrature points, x,
    and weights, w, associated with the Jacobi
    polynomial, of type (alpha, beta) > -1 ( <> -0.5).
    """

    if N == 0:
        return np.array([(alpha - beta) / (alpha + beta + 2)]), np.array([2])

    # Form symmetric matrix from recurrence.
    J = np.zeros(N + 1)
    h1 = 2 * np.arange(N + 1) + alpha + beta
    temp = np.arange(N) + 1.0
    J = np.diag(-1.0 / 2.0 * (alpha**2 - beta**2) / (h1 + 2.0) / h1) + np.diag(
        2.0 / (h1[0:N] + 2.0) * np.sqrt(temp * (temp + alpha + beta) *
                                        (temp + alpha) * (temp + beta) /
                                        (h1[0:N] + 1.0) / (h1[0:N] + 3.0)), 1)

    if alpha + beta < 10 * np.finfo(float).eps:
        J[0, 0] = 0.0
    J = J + J.T

    # Compute quadrature by eigenvalue solve
    D, V = la.eig(J)
    ind = np.argsort(D)
    D = D[ind]
    V = V[:, ind]
    x = D
    w = (V[0, :].T)**2 * 2**(alpha + beta + 1) / (alpha + beta + 1) * fact(
        alpha + 1) * fact(beta + 1) / fact(alpha + beta + 1)

    return x, w
Ejemplo n.º 2
0
def JacobiGQ(alpha, beta, N):
    """Compute the N'th order Gauss quadrature points, x,
    and weights, w, associated with the Jacobi
    polynomial, of type (alpha, beta) > -1 ( <> -0.5).
    """

    if N==0:
        return np.array([(alpha-beta)/(alpha+beta+2)]), np.array([2])

    # Form symmetric matrix from recurrence.
    J    = np.zeros(N+1)
    h1   = 2*np.arange(N+1) + alpha + beta
    temp = np.arange(N) + 1.0
    J    = np.diag(-1.0/2.0*(alpha**2-beta**2)/(h1+2.0)/h1) + np.diag(2.0/(h1[0:N]+2.0)*np.sqrt(temp*(temp+alpha+beta)*(temp+alpha)*(temp+beta)/(h1[0:N]+1.0)/(h1[0:N]+3.0)),1)

    if alpha+beta < 10*np.finfo(float).eps :
        J[0,0] = 0.0
    J = J + J.T

    # Compute quadrature by eigenvalue solve
    D, V = la.eig(J)
    ind = np.argsort(D)
    D = D[ind]
    V = V[:, ind]
    x = D
    w = (V[0,:].T)**2*2**(alpha+beta+1)/(alpha+beta+1)*fact(alpha+1)*fact(beta+1)/fact(alpha+beta+1)

    return x, w
Ejemplo n.º 3
0
def JacobiP(x, alpha, beta, N):
    """ function P = JacobiP(x, alpha, beta, N)
         Purpose: Evaluate Jacobi Polynomial of type (alpha, beta) > -1
                  (alpha+beta <> -1) at points x for order N and
                  returns P[1:length(xp))]
         Note   : They are normalized to be orthonormal."""
    N = np.int32(N)
    Nx = len(x)
    if x.shape[0] > 1:
        x = x.T
    # Storage for recursive construction
    PL = np.zeros((np.int32(Nx), np.int32(N + 1)))

    # Initial values P_0(x) and P_1(x)
    gamma0 = np.power(2., alpha + beta + 1) / (alpha + beta + 1.) * fact(
        alpha + 1) * fact(beta + 1) / fact(alpha + beta + 1)

    #
    PL[:, 0] = 1.0 / sqrt(gamma0)
    if N == 0:
        return PL[:, 0]

    gamma1 = (alpha + 1) * (beta + 1) / (alpha + beta + 3) * gamma0
    PL[:, 1] = ((alpha + beta + 2) * x / 2 + (alpha - beta) / 2) / sqrt(gamma1)
    if N == 1:
        return PL[:, 1]

    # Repeat value in recurrence.
    aold = 2. / (2. + alpha + beta) * sqrt(
        (alpha + 1.) * (beta + 1.) / (alpha + beta + 3.))

    # Forward recurrence using the symmetry of the recurrence.
    for i in range(1, N):
        h1 = 2. * i + alpha + beta

        foo = (i + 1.) * (i + 1. + alpha + beta) * (i + 1. + alpha) * (
            i + 1. + beta) / (h1 + 1.) / (h1 + 3.)
        anew = 2. / (h1 + 2.) * sqrt(foo)

        bnew = -(alpha * alpha - beta * beta) / (h1 * (h1 + 2.))
        PL[:, i +
           1] = (-aold * PL[:, i - 1] + np.multiply(x - bnew, PL[:, i])) / anew
        aold = anew

    return PL[:, N]
Ejemplo n.º 4
0
def JacobiP(x, alpha, beta, N):
    """ function P = JacobiP(x, alpha, beta, N)
         Purpose: Evaluate Jacobi Polynomial of type (alpha, beta) > -1
                  (alpha+beta <> -1) at points x for order N and
                  returns P[1:length(xp))]
         Note   : They are normalized to be orthonormal."""
    N = np.int32(N)
    Nx = len(x)
    if x.shape[0]>1:
        x = x.T
    # Storage for recursive construction
    PL = np.zeros((np.int32(Nx), np.int32(N+1)))

    # Initial values P_0(x) and P_1(x)
    gamma0 = np.power(2., alpha+beta+1)/(alpha+beta+1.)*fact(alpha+1)*fact(beta+1)/fact(alpha+beta+1)

    #
    PL[:,0] = 1.0/sqrt(gamma0)
    if N==0:
        return PL[:,0]

    gamma1 = (alpha+1)*(beta+1)/(alpha+beta+3)*gamma0
    PL[:,1] = ((alpha+beta+2)*x/2 + (alpha-beta)/2)/sqrt(gamma1)
    if N==1:
        return PL[:,1]

    # Repeat value in recurrence.
    aold = 2./(2.+alpha+beta)*sqrt((alpha+1.)*(beta+1.)/(alpha+beta+3.))

    # Forward recurrence using the symmetry of the recurrence.
    for i in range(1, N):
            h1 = 2.*i+alpha+beta

            foo = (i+1.)*(i+1.+alpha+beta)*(i+1.+alpha)*(i+1.+beta)/(h1+1.)/(h1+3.)
            anew = 2./(h1+2.)*sqrt(foo)

            bnew = -(alpha*alpha-beta*beta)/(h1*(h1+2.))
            PL[:, i+1] = ( -aold*PL[:, i-1] + np.multiply(x-bnew, PL[:, i]) )/anew
            aold = anew

    return PL[:, N]