MAGMA 2.9.0
Matrix Algebra for GPU and Multicore Architectures
Loading...
Searching...
No Matches
Functions
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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ACOMPLEX 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BCOMPLEX 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]dACOMPLEX 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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in]dBCOMPLEX array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by CPOTRF.
[in]lddbINTEGER The leading dimension of the array B. LDDB >= max(1,N).
[out]infoINTEGER
  • = 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]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ACOMPLEX 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BCOMPLEX 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ADOUBLE 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BDOUBLE 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]dADOUBLE 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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in]dBDOUBLE PRECISION array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by DPOTRF.
[in]lddbINTEGER The leading dimension of the array B. LDDB >= max(1,N).
[out]infoINTEGER
  • = 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]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ADOUBLE 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BDOUBLE 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]AREAL 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BREAL 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]dAREAL 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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in]dBREAL array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by SPOTRF.
[in]lddbINTEGER The leading dimension of the array B. LDDB >= max(1,N).
[out]infoINTEGER
  • = 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]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]AREAL 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BREAL 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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ACOMPLEX_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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BCOMPLEX_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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 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]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]dACOMPLEX_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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in]dBCOMPLEX_16 array, on the GPU device, dimension (LDDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.
[in]lddbINTEGER The leading dimension of the array B. LDDB >= max(1,N).
[out]infoINTEGER
  • = 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]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]itypeINTEGER = 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]uplomagma_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]nINTEGER The order of the matrices A and B. N >= 0.
[in,out]ACOMPLEX_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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[in,out]BCOMPLEX_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]ldbINTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value