Loading...
Searching...
No Matches
hegst: Reduce generalized problem to standard problem.
Dense LA » Eigenvalues » Generalized Symmetric/Hermitian eigenvalues » Auxiliary routines

## Functions

magma_int_t | magma_chegst (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *B, magma_int_t ldb, magma_int_t *info)
| CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form.
magma_int_t | magma_chegst_gpu (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaFloatComplex_const_ptr dB, magma_int_t lddb, magma_int_t *info)
| CHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form.
magma_int_t | magma_chegst_m (magma_int_t ngpu, magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *B, magma_int_t ldb, magma_int_t *info)
| CHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form.
magma_int_t | magma_dsygst (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, double *A, magma_int_t lda, double *B, magma_int_t ldb, magma_int_t *info)
| DSYGST reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_dsygst_gpu (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaDouble_ptr dA, magma_int_t ldda, magmaDouble_const_ptr dB, magma_int_t lddb, magma_int_t *info)
| DSYGST_GPU reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_dsygst_m (magma_int_t ngpu, magma_int_t itype, magma_uplo_t uplo, magma_int_t n, double *A, magma_int_t lda, double *B, magma_int_t ldb, magma_int_t *info)
| DSYGST_M reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_ssygst (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *B, magma_int_t ldb, magma_int_t *info)
| SSYGST reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_ssygst_gpu (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magmaFloat_const_ptr dB, magma_int_t lddb, magma_int_t *info)
| SSYGST_GPU reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_ssygst_m (magma_int_t ngpu, magma_int_t itype, magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *B, magma_int_t ldb, magma_int_t *info)
| SSYGST_M reduces a real symmetric-definite generalized eigenproblem to standard form.
magma_int_t | magma_zhegst (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *B, magma_int_t ldb, magma_int_t *info)
| ZHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form.
magma_int_t | magma_zhegst_gpu (magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magma_int_t *info)
| ZHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form.
magma_int_t | magma_zhegst_m (magma_int_t ngpu, magma_int_t itype, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *B, magma_int_t ldb, magma_int_t *info)
| ZHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form.

## Detailed Description

## Function Documentation

## magma_chegst()

magma_int_t magma_chegst | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloatComplex * | A,
|  | magma_int_t | lda,
|  | magmaFloatComplex * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

CHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 CPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | COMPLEX array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF.

B is modified by the routine but restored on exit (in lapack chegst/chegs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_chegst_gpu()

magma_int_t magma_chegst_gpu | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloatComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloatComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magma_int_t * | info )

CHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 CPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  dA

  COMPLEX array, on the GPU device, dimension (LDDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N).
  [in] | dB | COMPLEX array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF.
  [in] | lddb | INTEGER The leading dimension of the array B. LDDB >= max(1,N).

  [out]

  info

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

## magma_chegst_m()

magma_int_t magma_chegst_m | ( | magma_int_t | ngpu,
|  | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloatComplex * | A,
|  | magma_int_t | lda,
|  | magmaFloatComplex * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

CHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 CPOTRF.

Parameters

  [in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0.
  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U**H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L**H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  COMPLEX array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | COMPLEX array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF.

B is modified by the routine but restored on exit (in lapack chegst/chegs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_dsygst()

magma_int_t magma_dsygst | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | double * | A,
|  | magma_int_t | lda,
|  | double * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

DSYGST reduces a real symmetric-definite generalized eigenproblem to standard form.

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 DPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  DOUBLE PRECISION array, dimension (LDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | DOUBLE PRECISION array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by DPOTRF.

B is modified by the routine but restored on exit (in lapack dsygst/dsygs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_dsygst_gpu()

magma_int_t magma_dsygst_gpu | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDouble_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDouble_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magma_int_t * | info )

DSYGST_GPU reduces a real symmetric-definite generalized eigenproblem to standard form.

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 DPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  dA

  DOUBLE PRECISION array, on the GPU device, dimension (LDDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N).
  [in] | dB | DOUBLE PRECISION array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by DPOTRF.
  [in] | lddb | INTEGER The leading dimension of the array B. LDDB >= max(1,N).

  [out]

  info

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

## magma_dsygst_m()

magma_int_t magma_dsygst_m | ( | magma_int_t | ngpu,
|  | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | double * | A,
|  | magma_int_t | lda,
|  | double * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

DSYGST_M reduces a real symmetric-definite generalized eigenproblem to standard form.

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 DPOTRF.

Parameters

  [in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0.
  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U**H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L**H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  DOUBLE PRECISION array, dimension (LDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | DOUBLE PRECISION array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by DPOTRF.

B is modified by the routine but restored on exit (in lapack dsygst/dsygs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_ssygst()

magma_int_t magma_ssygst | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | float * | A,
|  | magma_int_t | lda,
|  | float * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

SSYGST reduces a real symmetric-definite generalized eigenproblem to standard form.

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 SPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  REAL array, dimension (LDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | REAL array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by SPOTRF.

B is modified by the routine but restored on exit (in lapack ssygst/ssygs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_ssygst_gpu()

magma_int_t magma_ssygst_gpu | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaFloat_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaFloat_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magma_int_t * | info )

SSYGST_GPU reduces a real symmetric-definite generalized eigenproblem to standard form.

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 SPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  dA

  REAL array, on the GPU device, dimension (LDDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N).
  [in] | dB | REAL array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by SPOTRF.
  [in] | lddb | INTEGER The leading dimension of the array B. LDDB >= max(1,N).

  [out]

  info

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

## magma_ssygst_m()

magma_int_t magma_ssygst_m | ( | magma_int_t | ngpu,
|  | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | float * | A,
|  | magma_int_t | lda,
|  | float * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

SSYGST_M reduces a real symmetric-definite generalized eigenproblem to standard form.

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 SPOTRF.

Parameters

  [in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0.
  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U**H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L**H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  REAL array, dimension (LDA,N) On entry, the symmetric matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | REAL array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by SPOTRF.

B is modified by the routine but restored on exit (in lapack ssygst/ssygs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_zhegst()

magma_int_t magma_zhegst | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDoubleComplex * | A,
|  | magma_int_t | lda,
|  | magmaDoubleComplex * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

ZHEGST reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 ZPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  COMPLEX_16 array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | COMPLEX_16 array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.

B is modified by the routine but restored on exit (in lapack zhegst/zhegs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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

## magma_zhegst_gpu()

magma_int_t magma_zhegst_gpu | ( | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDoubleComplex_ptr | dA,
|  | magma_int_t | ldda,
|  | magmaDoubleComplex_const_ptr | dB,
|  | magma_int_t | lddb,
|  | magma_int_t * | info )

ZHEGST_GPU reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 ZPOTRF.

Parameters

  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U^H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L^H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  dA

  COMPLEX_16 array, on the GPU device, dimension (LDDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,N).
  [in] | dB | COMPLEX_16 array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.
  [in] | lddb | INTEGER The leading dimension of the array B. LDDB >= max(1,N).

  [out]

  info

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

## magma_zhegst_m()

magma_int_t magma_zhegst_m | ( | magma_int_t | ngpu,
|  | magma_int_t | itype,
|  | magma_uplo_t | uplo,
|  | magma_int_t | n,
|  | magmaDoubleComplex * | A,
|  | magma_int_t | lda,
|  | magmaDoubleComplex * | B,
|  | magma_int_t | ldb,
|  | magma_int_t * | info )

ZHEGST_M reduces a complex Hermitian-definite generalized eigenproblem to standard form.

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 ZPOTRF.

Parameters

  [in] | ngpu | INTEGER Number of GPUs to use. ngpu > 0.
  [in] | itype | 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.

  [in]

  uplo

  magma_uplo_t
  - = MagmaUpper: Upper triangle of A is stored and B is factored as U**H*U;
  - = MagmaLower: Lower triangle of A is stored and B is factored as L*L**H.

  [in] | n | INTEGER The order of the matrices A and B. N >= 0.

  [in,out]

  A

  COMPLEX_16 array, dimension (LDA,N) On entry, the Hermitian matrix A. If UPLO = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = MagmaLower, the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
  On exit, if INFO = 0, the transformed matrix, stored in the same format as A.

  [in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,N).
  [in,out] | B | COMPLEX_16 array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.

B is modified by the routine but restored on exit (in lapack zhegst/zhegs2).

Parameters

  [in] | ldb | INTEGER The leading dimension of the array B. LDB >= max(1,N).

  [out]

  info

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