hpgst(3)

NAME
hpgst - {hp,sp}gst: reduction to standard form, packed

SYNOPSIS

  Functions

subroutine chpgst (itype, uplo, n, ap, bp, info)
CHPGST
subroutine dspgst (itype, uplo, n, ap, bp, info)
DSPGST
subroutine sspgst (itype, uplo, n, ap, bp, info)
SSPGST
subroutine zhpgst (itype, uplo, n, ap, bp, info)
ZHPGST

Detailed Description

Function Documentation

  subroutine chpgst (integer itype, character uplo, integer n, complex, dimension( * ) ap, complex, dimension( * ) bp, integer info)

CHPGST

Purpose:

    !>
    !> CHPGST reduces a complex Hermitian-definite generalized
    !> eigenproblem to standard form, using packed storage.
    !>
    !> If ITYPE = 1, the problem is A*x = lambda*B*x,
    !> and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
    !>
    !> If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
    !> B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.
    !>
    !> B must have been previously factorized as U**H*U or L*L**H by CPPTRF.
    !>

Parameters
    ITYPE

    !>          ITYPE is INTEGER
    !>          = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);
    !>          = 2 or 3: compute U*A*U**H or L**H*A*L.
    !>

    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored and B is factored as
    !>                  U**H*U;
    !>          = 'L':  Lower triangle of A is stored and B is factored as
    !>                  L*L**H.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A and B.  N >= 0.
    !>

    AP

    !>          AP is COMPLEX array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the Hermitian matrix
    !>          A, packed columnwise in a linear array.  The j-th column of A
    !>          is stored in the array AP as follows:
    !>          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
    !>          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
    !>
    !>          On exit, if INFO = 0, the transformed matrix, stored in the
    !>          same format as A.
    !>

    BP

    !>          BP is COMPLEX array, dimension (N*(N+1)/2)
    !>          The triangular factor from the Cholesky factorization of B,
    !>          stored in the same format as A, as returned by CPPTRF.
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -i, the i-th argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

  subroutine dspgst (integer itype, character uplo, integer n, double precision, dimension( * ) ap, double precision, dimension( * ) bp, integer info)

DSPGST

Purpose:

    !>
    !> DSPGST reduces a real symmetric-definite generalized eigenproblem
    !> to standard form, using packed storage.
    !>
    !> If ITYPE = 1, the problem is A*x = lambda*B*x,
    !> and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)
    !>
    !> If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
    !> B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.
    !>
    !> B must have been previously factorized as U**T*U or L*L**T by DPPTRF.
    !>

Parameters
    ITYPE

    !>          ITYPE is INTEGER
    !>          = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);
    !>          = 2 or 3: compute U*A*U**T or L**T*A*L.
    !>

    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored and B is factored as
    !>                  U**T*U;
    !>          = 'L':  Lower triangle of A is stored and B is factored as
    !>                  L*L**T.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A and B.  N >= 0.
    !>

    AP

    !>          AP is DOUBLE PRECISION array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the symmetric matrix
    !>          A, packed columnwise in a linear array.  The j-th column of A
    !>          is stored in the array AP as follows:
    !>          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
    !>          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
    !>
    !>          On exit, if INFO = 0, the transformed matrix, stored in the
    !>          same format as A.
    !>

    BP

    !>          BP is DOUBLE PRECISION array, dimension (N*(N+1)/2)
    !>          The triangular factor from the Cholesky factorization of B,
    !>          stored in the same format as A, as returned by DPPTRF.
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -i, the i-th argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

  subroutine sspgst (integer itype, character uplo, integer n, real, dimension( * ) ap, real, dimension( * ) bp, integer info)

SSPGST

Purpose:

    !>
    !> SSPGST reduces a real symmetric-definite generalized eigenproblem
    !> to standard form, using packed storage.
    !>
    !> If ITYPE = 1, the problem is A*x = lambda*B*x,
    !> and A is overwritten by inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T)
    !>
    !> If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
    !> B*A*x = lambda*x, and A is overwritten by U*A*U**T or L**T*A*L.
    !>
    !> B must have been previously factorized as U**T*U or L*L**T by SPPTRF.
    !>

Parameters
    ITYPE

    !>          ITYPE is INTEGER
    !>          = 1: compute inv(U**T)*A*inv(U) or inv(L)*A*inv(L**T);
    !>          = 2 or 3: compute U*A*U**T or L**T*A*L.
    !>

    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored and B is factored as
    !>                  U**T*U;
    !>          = 'L':  Lower triangle of A is stored and B is factored as
    !>                  L*L**T.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A and B.  N >= 0.
    !>

    AP

    !>          AP is REAL array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the symmetric matrix
    !>          A, packed columnwise in a linear array.  The j-th column of A
    !>          is stored in the array AP as follows:
    !>          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
    !>          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
    !>
    !>          On exit, if INFO = 0, the transformed matrix, stored in the
    !>          same format as A.
    !>

    BP

    !>          BP is REAL array, dimension (N*(N+1)/2)
    !>          The triangular factor from the Cholesky factorization of B,
    !>          stored in the same format as A, as returned by SPPTRF.
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -i, the i-th argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

  subroutine zhpgst (integer itype, character uplo, integer n, complex*16, dimension( * ) ap, complex*16, dimension( * ) bp, integer info)

ZHPGST

Purpose:

    !>
    !> ZHPGST reduces a complex Hermitian-definite generalized
    !> eigenproblem to standard form, using packed storage.
    !>
    !> If ITYPE = 1, the problem is A*x = lambda*B*x,
    !> and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)
    !>
    !> If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
    !> B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.
    !>
    !> B must have been previously factorized as U**H*U or L*L**H by ZPPTRF.
    !>

Parameters
    ITYPE

    !>          ITYPE is INTEGER
    !>          = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);
    !>          = 2 or 3: compute U*A*U**H or L**H*A*L.
    !>

    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored and B is factored as
    !>                  U**H*U;
    !>          = 'L':  Lower triangle of A is stored and B is factored as
    !>                  L*L**H.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrices A and B.  N >= 0.
    !>

    AP

    !>          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the Hermitian matrix
    !>          A, packed columnwise in a linear array.  The j-th column of A
    !>          is stored in the array AP as follows:
    !>          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
    !>          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
    !>
    !>          On exit, if INFO = 0, the transformed matrix, stored in the
    !>          same format as A.
    !>

    BP

    !>          BP is COMPLEX*16 array, dimension (N*(N+1)/2)
    !>          The triangular factor from the Cholesky factorization of B,
    !>          stored in the same format as A, as returned by ZPPTRF.
    !>

    INFO

    !>          INFO is INTEGER
    !>          = 0:  successful exit
    !>          < 0:  if INFO = -i, the i-th argument had an illegal value
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Author

Generated automatically by Doxygen for LAPACK from the source code.