double-complex precision

Functions

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_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.
magma_int_t magma_zhetrd (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, double *d, double *e, magmaDoubleComplex *tau, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
 ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
magma_int_t magma_zhetrd2_gpu (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, double *d, double *e, magmaDoubleComplex *tau, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *work, magma_int_t lwork, magmaDoubleComplex_ptr dwork, magma_int_t ldwork, magma_int_t *info)
 ZHETRD2_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
magma_int_t magma_zhetrd_gpu (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, double *d, double *e, magmaDoubleComplex *tau, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
 ZHETRD_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
magma_int_t magma_zhetrd_mgpu (magma_int_t ngpu, magma_int_t nqueue, magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, double *d, double *e, magmaDoubleComplex *tau, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
 ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.
magma_int_t magma_zstedx (magma_range_t range, magma_int_t n, double vl, double vu, magma_int_t il, magma_int_t iu, double *d, double *e, magmaDoubleComplex *Z, magma_int_t ldz, double *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magmaDouble_ptr dwork, magma_int_t *info)
 ZSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
magma_int_t magma_zstedx_m (magma_int_t ngpu, magma_range_t range, magma_int_t n, double vl, double vu, magma_int_t il, magma_int_t iu, double *d, double *e, magmaDoubleComplex *Z, magma_int_t ldz, double *rwork, magma_int_t lrwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
 ZSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.
magma_int_t magma_zungtr (magma_uplo_t uplo, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex *work, magma_int_t lwork, magmaDoubleComplex *dT, magma_int_t nb, magma_int_t *info)
 ZUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD:.
magma_int_t magma_zunmtr (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex *C, magma_int_t ldc, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
 ZUNMTR overwrites the general complex M-by-N matrix C with.
magma_int_t magma_zunmtr_gpu (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex *tau, magmaDoubleComplex_ptr dC, magma_int_t lddc, magmaDoubleComplex *wA, magma_int_t ldwa, magma_int_t *info)
 ZUNMTR overwrites the general complex M-by-N matrix C with.
magma_int_t magma_zunmtr_m (magma_int_t ngpu, magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex *C, magma_int_t ldc, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
 ZUNMTR overwrites the general complex M-by-N matrix C with.

Function Documentation

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] B COMPLEX_16 array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.
[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_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_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, 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] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in] dB COMPLEX_16 array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.
[in] lddb 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_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] B COMPLEX_16 array, dimension (LDB,N) The triangular factor from the Cholesky factorization of B, as returned by ZPOTRF.
[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_int_t magma_zhetrd ( magma_uplo_t  uplo,
magma_int_t  n,
magmaDoubleComplex *  A,
magma_int_t  lda,
double *  d,
double *  e,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.

Parameters:
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in] n INTEGER The order of the matrix A. 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out] d COMPLEX_16 array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out] e COMPLEX_16 array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower.
[out] tau COMPLEX_16 array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_zhetrd_nb().
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out] info INTEGER

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

Further Details --------------- If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors

Q = H(n-1) . . . H(2) H(1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).

If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(n-1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).

The contents of A on exit are illustrated by the following examples with n = 5:

if UPLO = MagmaUpper: if UPLO = MagmaLower:

( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )

where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).

magma_int_t magma_zhetrd2_gpu ( magma_uplo_t  uplo,
magma_int_t  n,
magmaDoubleComplex_ptr  dA,
magma_int_t  ldda,
double *  d,
double *  e,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  A,
magma_int_t  lda,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magmaDoubleComplex_ptr  dwork,
magma_int_t  ldwork,
magma_int_t *  info 
)

ZHETRD2_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.

This version passes a workspace that is used in an optimized GPU matrix-vector product.

Parameters:
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in] n INTEGER The order of the matrix A. N >= 0.
[in,out] dA COMPLEX_16 array on the GPU, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,N).
[out] d COMPLEX_16 array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out] e COMPLEX_16 array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower.
[out] tau COMPLEX_16 array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out] A (workspace) COMPLEX_16 array, dimension (LDA,N) On exit the diagonal, the upper part (UPLO=MagmaUpper) or the lower part (UPLO=MagmaLower) are copies of DA
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_zhetrd_nb().
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out] dwork (workspace) COMPLEX_16 array on the GPU, dim (MAX(1,LDWORK))
[in] ldwork INTEGER The dimension of the array DWORK. LDWORK >= ldda*ceil(n/64) + 2*ldda*nb, where nb = magma_get_zhetrd_nb(n), and 64 is for the blocksize of magmablas_zhemv.
[out] info INTEGER

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

Further Details --------------- If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors

Q = H(n-1) . . . H(2) H(1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).

If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(n-1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).

The contents of A on exit are illustrated by the following examples with n = 5:

if UPLO = MagmaUpper: if UPLO = MagmaLower:

( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )

where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).

magma_int_t magma_zhetrd_gpu ( magma_uplo_t  uplo,
magma_int_t  n,
magmaDoubleComplex_ptr  dA,
magma_int_t  ldda,
double *  d,
double *  e,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  A,
magma_int_t  lda,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

ZHETRD_GPU reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.

Parameters:
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in] n INTEGER The order of the matrix A. N >= 0.
[in,out] dA COMPLEX_16 array on the GPU, 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,N).
[out] d COMPLEX_16 array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out] e COMPLEX_16 array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower.
[out] tau COMPLEX_16 array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out] A (workspace) COMPLEX_16 array, dimension (LDA,N) On exit the diagonal, the upper part (UPLO=MagmaUpper) or the lower part (UPLO=MagmaLower) are copies of DA
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_zhetrd_nb().
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out] info INTEGER

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

Further Details --------------- If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors

Q = H(n-1) . . . H(2) H(1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).

If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(n-1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).

The contents of A on exit are illustrated by the following examples with n = 5:

if UPLO = MagmaUpper: if UPLO = MagmaLower:

( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )

where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).

magma_int_t magma_zhetrd_mgpu ( magma_int_t  ngpu,
magma_int_t  nqueue,
magma_uplo_t  uplo,
magma_int_t  n,
magmaDoubleComplex *  A,
magma_int_t  lda,
double *  d,
double *  e,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

ZHETRD reduces a complex Hermitian matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T.

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] nqueue INTEGER The number of GPU streams used for update. 10 >= nqueue > 0.
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in] n INTEGER The order of the matrix A. 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 UPLO = MagmaUpper, the diagonal and first superdiagonal of A are overwritten by the corresponding elements of the tridiagonal matrix T, and the elements above the first superdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors; if UPLO = MagmaLower, the diagonal and first subdiagonal of A are over- written by the corresponding elements of the tridiagonal matrix T, and the elements below the first subdiagonal, with the array TAU, represent the orthogonal matrix Q as a product of elementary reflectors. See Further Details.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out] d COMPLEX_16 array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out] e COMPLEX_16 array, dimension (N-1) The off-diagonal elements of the tridiagonal matrix T: E(i) = A(i,i+1) if UPLO = MagmaUpper, E(i) = A(i+1,i) if UPLO = MagmaLower.
[out] tau COMPLEX_16 array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_zhetrd_nb().
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out] info INTEGER

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

Further Details --------------- If UPLO = MagmaUpper, the matrix Q is represented as a product of elementary reflectors

Q = H(n-1) . . . H(2) H(1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in A(1:i-1,i+1), and tau in TAU(i).

If UPLO = MagmaLower, the matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(n-1).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in A(i+2:n,i), and tau in TAU(i).

The contents of A on exit are illustrated by the following examples with n = 5:

if UPLO = MagmaUpper: if UPLO = MagmaLower:

( d e v2 v3 v4 ) ( d ) ( d e v3 v4 ) ( e d ) ( d e v4 ) ( v1 e d ) ( d e ) ( v1 v2 e d ) ( d ) ( v1 v2 v3 e d )

where d and e denote diagonal and off-diagonal elements of T, and vi denotes an element of the vector defining H(i).

magma_int_t magma_zstedx ( magma_range_t  range,
magma_int_t  n,
double  vl,
double  vu,
magma_int_t  il,
magma_int_t  iu,
double *  d,
double *  e,
magmaDoubleComplex *  Z,
magma_int_t  ldz,
double *  rwork,
magma_int_t  lrwork,
magma_int_t *  iwork,
magma_int_t  liwork,
magmaDouble_ptr  dwork,
magma_int_t *  info 
)

ZSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.

This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAEX3 for details.

Parameters:
[in] range magma_range_t

  • = MagmaRangeAll: all eigenvalues will be found.
  • = MagmaRangeV: all eigenvalues in the half-open interval (VL,VU] will be found.
  • = MagmaRangeI: the IL-th through IU-th eigenvalues will be found.
[in] n INTEGER The dimension of the symmetric tridiagonal matrix. N >= 0.
[in] vl DOUBLE PRECISION
[in] vu DOUBLE PRECISION If RANGE=MagmaRangeV, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = MagmaRangeAll or MagmaRangeI.
[in] il INTEGER
[in] iu INTEGER If RANGE=MagmaRangeI, the indices (in ascending order) of the smallest and largest eigenvalues to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = MagmaRangeAll or MagmaRangeV.
[in,out] d DOUBLE PRECISION array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order.
[in,out] e DOUBLE PRECISION array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed.
[out] Z COMPLEX_16 array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix.
[in] ldz INTEGER The leading dimension of the array Z. LDZ >= max(1,N).
[out] rwork (workspace) DOUBLE PRECISION array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in] lrwork INTEGER The dimension of the array RWORK. LRWORK >= 1 + 4*N + 2*N**2. Note that if N is less than or equal to the minimum divide size, usually 25, then LRWORK need only be max(1,2*(N-1)).
If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out] iwork (workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in] liwork INTEGER The dimension of the array IWORK. LIWORK >= 3 + 5*N . Note that if N is less than or equal to the minimum divide size, usually 25, then LIWORK need only be 1.
If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
dwork (workspace) DOUBLE PRECISION array, dimension (3*N*N/2+3*N)
[out] info INTEGER

  • = 0: successful exit.
  • < 0: if INFO = -i, the i-th argument had an illegal value.
  • > 0: The algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details --------------- Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

magma_int_t magma_zstedx_m ( magma_int_t  ngpu,
magma_range_t  range,
magma_int_t  n,
double  vl,
double  vu,
magma_int_t  il,
magma_int_t  iu,
double *  d,
double *  e,
magmaDoubleComplex *  Z,
magma_int_t  ldz,
double *  rwork,
magma_int_t  lrwork,
magma_int_t *  iwork,
magma_int_t  liwork,
magma_int_t *  info 
)

ZSTEDX computes some eigenvalues and eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method.

This code makes very mild assumptions about floating point arithmetic. It will work on machines with a guard digit in add/subtract, or on those binary machines without guard digits which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2. It could conceivably fail on hexadecimal or decimal machines without guard digits, but we know of none. See DLAEX3 for details.

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] range magma_range_t

  • = MagmaRangeAll: all eigenvalues will be found.
  • = MagmaRangeV: all eigenvalues in the half-open interval (VL,VU] will be found.
  • = MagmaRangeI: the IL-th through IU-th eigenvalues will be found.
[in] n INTEGER The dimension of the symmetric tridiagonal matrix. N >= 0.
[in] vl DOUBLE PRECISION
[in] vu DOUBLE PRECISION If RANGE=MagmaRangeV, the lower and upper bounds of the interval to be searched for eigenvalues. VL < VU. Not referenced if RANGE = MagmaRangeAll or MagmaRangeI.
[in] il INTEGER
[in] iu INTEGER If RANGE=MagmaRangeI, the indices (in ascending order) of the smallest and largest eigenvalues to be returned. 1 <= IL <= IU <= N, if N > 0; IL = 1 and IU = 0 if N = 0. Not referenced if RANGE = MagmaRangeAll or MagmaRangeV.
[in,out] d DOUBLE PRECISION array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order.
[in,out] e DOUBLE PRECISION array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed.
[out] Z COMPLEX_16 array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix.
[in] ldz INTEGER The leading dimension of the array Z. LDZ >= max(1,N).
[out] rwork (workspace) DOUBLE PRECISION array, dimension (LRWORK) On exit, if INFO = 0, RWORK[0] returns the optimal LRWORK.
[in] lrwork INTEGER The dimension of the array RWORK. LRWORK >= 1 + 4*N + 2*N**2 . Note that if N is less than or equal to the minimum divide size, usually 25, then LRWORK need only be max(1,2*(N-1)).
If LRWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out] iwork (workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in] liwork INTEGER The dimension of the array IWORK. LIWORK >= 3 + 5*N . Note that if N is less than or equal to the minimum divide size, usually 25, then LIWORK need only be 1.
If LIWORK = -1, then a workspace query is assumed; the routine only calculates the optimal sizes of the WORK, RWORK and IWORK arrays, returns these values as the first entries of the WORK, RWORK and IWORK arrays, and no error message related to LWORK or LRWORK or LIWORK is issued by XERBLA.
[out] info INTEGER

  • = 0: successful exit.
  • < 0: if INFO = -i, the i-th argument had an illegal value.
  • > 0: The algorithm failed to compute an eigenvalue while working on the submatrix lying in rows and columns INFO/(N+1) through mod(INFO,N+1).

Further Details --------------- Based on contributions by Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

magma_int_t magma_zungtr ( magma_uplo_t  uplo,
magma_int_t  n,
magmaDoubleComplex *  A,
magma_int_t  lda,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magmaDoubleComplex *  dT,
magma_int_t  nb,
magma_int_t *  info 
)

ZUNGTR generates a complex unitary matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by ZHETRD:.

if UPLO = MagmaUpper, Q = H(n-1) . . . H(2) H(1),

if UPLO = MagmaLower, Q = H(1) H(2) . . . H(n-1).

Parameters:
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A contains elementary reflectors from ZHETRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from ZHETRD.
[in] n INTEGER The order of the matrix Q. N >= 0.
[in,out] A COMPLEX_16 array, dimension (LDA,N) On entry, the vectors which define the elementary reflectors, as returned by ZHETRD. On exit, the N-by-N unitary matrix Q.
[in] lda INTEGER The leading dimension of the array A. LDA >= N.
[in] tau COMPLEX_16 array, dimension (N-1) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZHETRD.
[out] work (workspace) COMPLEX_16 array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. LWORK >= N-1. For optimum performance LWORK >= N*NB, where NB is the optimal blocksize.
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[in] dT COMPLEX_16 array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i) as returned by magma_zhetrd.
[in] nb INTEGER This is the block size used in ZHETRD, and correspondingly the size of the T matrices, used in the factorization, and stored in DT.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_zunmtr ( magma_side_t  side,
magma_uplo_t  uplo,
magma_trans_t  trans,
magma_int_t  m,
magma_int_t  n,
magmaDoubleComplex *  A,
magma_int_t  lda,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  C,
magma_int_t  ldc,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

ZUNMTR overwrites the general complex M-by-N matrix C with.

SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H

where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD:

if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);

if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).

Parameters:
[in] side magma_side_t

  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in] trans magma_trans_t

  • = MagmaNoTrans: No transpose, apply Q;
  • = Magma_ConjTrans: Conjugate transpose, apply Q**H.
[in] m INTEGER The number of rows of the matrix C. M >= 0.
[in] n INTEGER The number of columns of the matrix C. N >= 0.
[in] A COMPLEX_16 array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight.
[in] tau COMPLEX_16 array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD.
[in,out] C COMPLEX_16 array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H * C or C * Q**H or C*Q.
[in] ldc INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M). For optimum performance LWORK >= N*NB if SIDE = MagmaLeft, and LWORK >= M*NB if SIDE = MagmaRight, where NB is the optimal blocksize.
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_zunmtr_gpu ( magma_side_t  side,
magma_uplo_t  uplo,
magma_trans_t  trans,
magma_int_t  m,
magma_int_t  n,
magmaDoubleComplex_ptr  dA,
magma_int_t  ldda,
magmaDoubleComplex *  tau,
magmaDoubleComplex_ptr  dC,
magma_int_t  lddc,
magmaDoubleComplex *  wA,
magma_int_t  ldwa,
magma_int_t *  info 
)

ZUNMTR overwrites the general complex M-by-N matrix C with.

SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H

where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by ZHETRD:

if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);

if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).

Parameters:
[in] side magma_side_t

  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A contains elementary reflectors from ZHETRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from ZHETRD.
[in] trans magma_trans_t

  • = MagmaNoTrans: No transpose, apply Q;
  • = Magma_ConjTrans: Conjugate transpose, apply Q**H.
[in] m INTEGER The number of rows of the matrix C. M >= 0.
[in] n INTEGER The number of columns of the matrix C. N >= 0.
[in] dA COMPLEX_16 array, dimension (LDDA,M) if SIDE = MagmaLeft (LDDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by ZHETRD_GPU. On output the diagonal, the subdiagonal and the upper part (UPLO=MagmaLower) or lower part (UPLO=MagmaUpper) are destroyed.
[in] ldda INTEGER The leading dimension of the array DA. LDDA >= max(1,M) if SIDE = MagmaLeft; LDDA >= max(1,N) if SIDE = MagmaRight.
[in] tau COMPLEX_16 array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by ZHETRD.
[in,out] dC COMPLEX_16 array, dimension (LDDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by (Q*C) or (Q**H * C) or (C * Q**H) or (C*Q).
[in] lddc INTEGER The leading dimension of the array C. LDDC >= max(1,M).
[in] wA (workspace) COMPLEX_16 array, dimension (LDWA,M) if SIDE = MagmaLeft (LDWA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by ZHETRD_GPU.
[in] ldwa INTEGER The leading dimension of the array wA. LDWA >= max(1,M) if SIDE = MagmaLeft; LDWA >= max(1,N) if SIDE = MagmaRight.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_zunmtr_m ( magma_int_t  ngpu,
magma_side_t  side,
magma_uplo_t  uplo,
magma_trans_t  trans,
magma_int_t  m,
magma_int_t  n,
magmaDoubleComplex *  A,
magma_int_t  lda,
magmaDoubleComplex *  tau,
magmaDoubleComplex *  C,
magma_int_t  ldc,
magmaDoubleComplex *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

ZUNMTR overwrites the general complex M-by-N matrix C with.

SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q * C C * Q TRANS = Magma_ConjTrans: Q**H * C C * Q**H

where Q is a complex unitary matrix of order nq, with nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Q is defined as the product of nq-1 elementary reflectors, as returned by SSYTRD:

if UPLO = MagmaUpper, Q = H(nq-1) . . . H(2) H(1);

if UPLO = MagmaLower, Q = H(1) H(2) . . . H(nq-1).

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] side magma_side_t

  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in] uplo magma_uplo_t

  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in] trans magma_trans_t

  • = MagmaNoTrans: No transpose, apply Q;
  • = Magma_ConjTrans: Conjugate transpose, apply Q**H.
[in] m INTEGER The number of rows of the matrix C. M >= 0.
[in] n INTEGER The number of columns of the matrix C. N >= 0.
[in] A COMPLEX_16 array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight.
[in] tau COMPLEX_16 array, dimension (M-1) if SIDE = MagmaLeft (N-1) if SIDE = MagmaRight TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD.
[in,out] C COMPLEX_16 array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
[in] ldc INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out] work (workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in] lwork INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M). For optimum performance LWORK >= N*NB if SIDE = MagmaLeft, and LWORK >= M*NB if SIDE = MagmaRight, where NB is the optimal blocksize.
If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued.
[out] info INTEGER

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

Generated on 3 May 2015 for MAGMA by  doxygen 1.6.1