MAGMA  2.0.0
Matrix Algebra for GPU and Multicore Architectures

Functions

magma_int_t magma_sorgtr (magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *tau, float *work, magma_int_t lwork, float *dT, magma_int_t nb, magma_int_t *info)
 SORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD: More...
 
magma_int_t magma_sormtr (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, float *A, magma_int_t lda, float *tau, float *C, magma_int_t ldc, float *work, magma_int_t lwork, magma_int_t *info)
 SORMTR overwrites the general real M-by-N matrix C with. More...
 
magma_int_t magma_sormtr_gpu (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, float *tau, magmaFloat_ptr dC, magma_int_t lddc, const float *wA, magma_int_t ldwa, magma_int_t *info)
 SORMTR overwrites the general real M-by-N matrix C with. More...
 
magma_int_t magma_sormtr_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, float *A, magma_int_t lda, float *tau, float *C, magma_int_t ldc, float *work, magma_int_t lwork, magma_int_t *info)
 SORMTR overwrites the general real M-by-N matrix C with. More...
 
magma_int_t magma_sstedx (magma_range_t range, magma_int_t n, float vl, float vu, magma_int_t il, magma_int_t iu, float *d, float *e, float *Z, magma_int_t ldz, float *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magmaFloat_ptr dwork, magma_int_t *info)
 SSTEDX computes some eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. More...
 
magma_int_t magma_sstedx_m (magma_int_t ngpu, magma_range_t range, magma_int_t n, float vl, float vu, magma_int_t il, magma_int_t iu, float *d, float *e, float *Z, magma_int_t ldz, float *work, magma_int_t lwork, magma_int_t *iwork, magma_int_t liwork, magma_int_t *info)
 SSTEDX computes some eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer method. More...
 
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. More...
 
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. More...
 
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. More...
 
magma_int_t magma_ssytrd (magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *d, float *e, float *tau, float *work, magma_int_t lwork, magma_int_t *info)
 SSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More...
 
magma_int_t magma_ssytrd2_gpu (magma_uplo_t uplo, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, float *d, float *e, float *tau, float *A, magma_int_t lda, float *work, magma_int_t lwork, magmaFloat_ptr dwork, magma_int_t ldwork, magma_int_t *info)
 SSYTRD2_GPU reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More...
 
magma_int_t magma_ssytrd_gpu (magma_uplo_t uplo, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, float *d, float *e, float *tau, float *A, magma_int_t lda, float *work, magma_int_t lwork, magma_int_t *info)
 SSYTRD_GPU reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More...
 
magma_int_t magma_ssytrd_mgpu (magma_int_t ngpu, magma_int_t nqueue, magma_uplo_t uplo, magma_int_t n, float *A, magma_int_t lda, float *d, float *e, float *tau, float *work, magma_int_t lwork, magma_int_t *info)
 SSYTRD reduces a real symmetric matrix A to real symmetric tridiagonal form T by an orthogonal similarity transformation: Q**H * A * Q = T. More...
 

Detailed Description

Function Documentation

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

SORGTR generates a real orthogonal matrix Q which is defined as the product of n-1 elementary reflectors of order N, as returned by SSYTRD:

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

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

Parameters
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in]nINTEGER The order of the matrix Q. N >= 0.
[in,out]AREAL array, dimension (LDA,N) On entry, the vectors which define the elementary reflectors, as returned by SSYTRD. On exit, the N-by-N orthogonal matrix Q.
[in]ldaINTEGER The leading dimension of the array A. LDA >= N.
[in]tauREAL array, dimension (N-1) TAU(i) must contain the scalar factor of the elementary reflector H(i), as returned by SSYTRD.
[out]work(workspace) REAL array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER 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]dTREAL array on the GPU device. DT contains the T matrices used in blocking the elementary reflectors H(i) as returned by magma_ssytrd.
[in]nbINTEGER This is the block size used in SSYTRD, and correspondingly the size of the T matrices, used in the factorization, and stored in DT.
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_sormtr ( magma_side_t  side,
magma_uplo_t  uplo,
magma_trans_t  trans,
magma_int_t  m,
magma_int_t  n,
float *  A,
magma_int_t  lda,
float *  tau,
float *  C,
magma_int_t  ldc,
float *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

SORMTR overwrites the general real M-by-N matrix C with.

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

where Q is a real orthogonal 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]sidemagma_side_t
  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in]transmagma_trans_t
  • = MagmaNoTrans: No transpose, apply Q;
  • = MagmaTrans: Conjugate transpose, apply Q**H.
[in]mINTEGER The number of rows of the matrix C. M >= 0.
[in]nINTEGER The number of columns of the matrix C. N >= 0.
[in]AREAL array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD.
[in]ldaINTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight.
[in]tauREAL 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]CREAL 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]ldcINTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_sormtr_gpu ( magma_side_t  side,
magma_uplo_t  uplo,
magma_trans_t  trans,
magma_int_t  m,
magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
float *  tau,
magmaFloat_ptr  dC,
magma_int_t  lddc,
const float *  wA,
magma_int_t  ldwa,
magma_int_t *  info 
)

SORMTR overwrites the general real M-by-N matrix C with.

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

where Q is a real orthogonal 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]sidemagma_side_t
  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in]transmagma_trans_t
  • = MagmaNoTrans: No transpose, apply Q;
  • = MagmaTrans: Conjugate transpose, apply Q**H.
[in]mINTEGER The number of rows of the matrix C. M >= 0.
[in]nINTEGER The number of columns of the matrix C. N >= 0.
[in,out]dAREAL array, dimension (LDDA,M) if SIDE = MagmaLeft (LDDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD_GPU. On output the diagonal, the subdiagonal and the upper part (UPLO=MagmaLower) or lower part (UPLO=MagmaUpper) are destroyed.
[in]lddaINTEGER The leading dimension of the array dA. If SIDE = MagmaLeft, LDDA >= max(1,M); if SIDE = MagmaRight, LDDA >= max(1,N).
[in]tauREAL 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]dCREAL 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]lddcINTEGER The leading dimension of the array C. LDDC >= max(1,M).
[in]wAREAL array, dimension (LDWA,M) if SIDE = MagmaLeft (LDWA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD_GPU. (A copy of the upper or lower part of dA, on the host.)
[in]ldwaINTEGER The leading dimension of the array wA. If SIDE = MagmaLeft, LDWA >= max(1,M); if SIDE = MagmaRight, LDWA >= max(1,N).
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_sormtr_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,
float *  A,
magma_int_t  lda,
float *  tau,
float *  C,
magma_int_t  ldc,
float *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

SORMTR overwrites the general real M-by-N matrix C with.

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

where Q is a real orthogonal 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]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]sidemagma_side_t
  • = MagmaLeft: apply Q or Q**H from the Left;
  • = MagmaRight: apply Q or Q**H from the Right.
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A contains elementary reflectors from SSYTRD;
  • = MagmaLower: Lower triangle of A contains elementary reflectors from SSYTRD.
[in]transmagma_trans_t
  • = MagmaNoTrans: No transpose, apply Q;
  • = MagmaTrans: Conjugate transpose, apply Q**H.
[in]mINTEGER The number of rows of the matrix C. M >= 0.
[in]nINTEGER The number of columns of the matrix C. N >= 0.
[in]AREAL array, dimension (LDA,M) if SIDE = MagmaLeft (LDA,N) if SIDE = MagmaRight The vectors which define the elementary reflectors, as returned by SSYTRD.
[in]ldaINTEGER The leading dimension of the array A. LDA >= max(1,M) if SIDE = MagmaLeft; LDA >= max(1,N) if SIDE = MagmaRight.
[in]tauREAL 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]CREAL 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]ldcINTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER 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]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
magma_int_t magma_sstedx ( magma_range_t  range,
magma_int_t  n,
float  vl,
float  vu,
magma_int_t  il,
magma_int_t  iu,
float *  d,
float *  e,
float *  Z,
magma_int_t  ldz,
float *  work,
magma_int_t  lwork,
magma_int_t *  iwork,
magma_int_t  liwork,
magmaFloat_ptr  dwork,
magma_int_t *  info 
)

SSTEDX computes some eigenvalues and, optionally, 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 SLAEX3 for details.

Parameters
[in]rangemagma_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]nINTEGER The dimension of the symmetric tridiagonal matrix. N >= 0.
[in]vlREAL
[in]vuREAL 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]ilINTEGER
[in]iuINTEGER 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]dREAL array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order.
[in,out]eREAL array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed.
[in,out]ZREAL array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix.
[in]ldzINTEGER The leading dimension of the array Z. LDZ >= max(1,N).
[out]work(workspace) REAL array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. If N > 1 then LWORK >= ( 1 + 4*N + N**2 ). Note that if N is less than or equal to the minimum divide size, usually 25, then LWORK need only be max(1,2*(N-1)).
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]iwork(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]liworkINTEGER 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 size of the IWORK array, returns this value as the first entry of the IWORK array, and no error message related to LIWORK is issued by XERBLA.
dwork(workspace) REAL array, dimension (3*N*N/2+3*N)
[out]infoINTEGER
  • = 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 Modified by Francoise Tisseur, University of Tennessee.

magma_int_t magma_sstedx_m ( magma_int_t  ngpu,
magma_range_t  range,
magma_int_t  n,
float  vl,
float  vu,
magma_int_t  il,
magma_int_t  iu,
float *  d,
float *  e,
float *  Z,
magma_int_t  ldz,
float *  work,
magma_int_t  lwork,
magma_int_t *  iwork,
magma_int_t  liwork,
magma_int_t *  info 
)

SSTEDX computes some eigenvalues and, optionally, 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 SLAEX3 for details.

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]rangemagma_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]nINTEGER The dimension of the symmetric tridiagonal matrix. N >= 0.
[in]vlREAL
[in]vuREAL 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]ilINTEGER
[in]iuINTEGER 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]dREAL array, dimension (N) On entry, the diagonal elements of the tridiagonal matrix. On exit, if INFO = 0, the eigenvalues in ascending order.
[in,out]eREAL array, dimension (N-1) On entry, the subdiagonal elements of the tridiagonal matrix. On exit, E has been destroyed.
[in,out]ZREAL array, dimension (LDZ,N) On exit, if INFO = 0, Z contains the orthonormal eigenvectors of the symmetric tridiagonal matrix.
[in]ldzINTEGER The leading dimension of the array Z. LDZ >= max(1,N).
[out]work(workspace) REAL array, dimension (LWORK) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. If N > 1 then LWORK >= ( 1 + 4*N + N**2 ). Note that if N is less than or equal to the minimum divide size, usually 25, then LWORK need only be max(1,2*(N-1)).
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]iwork(workspace) INTEGER array, dimension (MAX(1,LIWORK)) On exit, if INFO = 0, IWORK[0] returns the optimal LIWORK.
[in]liworkINTEGER 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 size of the IWORK array, returns this value as the first entry of the IWORK array, and no error message related to LIWORK is issued by XERBLA.
[out]infoINTEGER
  • = 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 Modified by Francoise Tisseur, University of Tennessee.

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_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_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_int_t magma_ssytrd ( magma_uplo_t  uplo,
magma_int_t  n,
float *  A,
magma_int_t  lda,
float *  d,
float *  e,
float *  tau,
float *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

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

Parameters
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in]nINTEGER The order of the matrix A. 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 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]dREAL array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out]eREAL 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]tauREAL array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_ssytrd_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]infoINTEGER
  • = 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 real scalar, and v is a real 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 real scalar, and v is a real 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_ssytrd2_gpu ( magma_uplo_t  uplo,
magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
float *  d,
float *  e,
float *  tau,
float *  A,
magma_int_t  lda,
float *  work,
magma_int_t  lwork,
magmaFloat_ptr  dwork,
magma_int_t  ldwork,
magma_int_t *  info 
)

SSYTRD2_GPU reduces a real symmetric 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]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in]nINTEGER The order of the matrix A. N >= 0.
[in,out]dAREAL array on the GPU, 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 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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[out]dREAL array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out]eREAL 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]tauREAL array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out]A(workspace) REAL array, dimension (LDA,N) On exit the diagonal, the upper part (if uplo=MagmaUpper) or the lower part (if uplo=MagmaLower) are copies of DA
[in]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_ssytrd_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) REAL array on the GPU, dim (MAX(1,LDWORK))
[in]ldworkINTEGER The dimension of the array DWORK. LDWORK >= ldda*ceil(n/64) + 2*ldda*nb, where nb = magma_get_ssytrd_nb(n), and 64 is for the blocksize of magmablas_ssymv.
[out]infoINTEGER
  • = 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 real scalar, and v is a real 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 real scalar, and v is a real 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_ssytrd_gpu ( magma_uplo_t  uplo,
magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
float *  d,
float *  e,
float *  tau,
float *  A,
magma_int_t  lda,
float *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

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

Parameters
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in]nINTEGER The order of the matrix A. N >= 0.
[in,out]dAREAL array on the GPU, 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 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]lddaINTEGER The leading dimension of the array A. LDDA >= max(1,N).
[out]dREAL array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out]eREAL 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]tauREAL array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out]A(workspace) REAL array, dimension (LDA,N) On exit the diagonal, the upper part (if uplo=MagmaUpper) or the lower part (if uplo=MagmaLower) are copies of dA
[in]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_ssytrd_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]infoINTEGER
  • = 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 real scalar, and v is a real 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 real scalar, and v is a real 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_ssytrd_mgpu ( magma_int_t  ngpu,
magma_int_t  nqueue,
magma_uplo_t  uplo,
magma_int_t  n,
float *  A,
magma_int_t  lda,
float *  d,
float *  e,
float *  tau,
float *  work,
magma_int_t  lwork,
magma_int_t *  info 
)

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

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]nqueueINTEGER The number of GPU queues used for update. 10 >= nqueue > 0.
[in]uplomagma_uplo_t
  • = MagmaUpper: Upper triangle of A is stored;
  • = MagmaLower: Lower triangle of A is stored.
[in]nINTEGER The order of the matrix A. 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 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]ldaINTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]dREAL array, dimension (N) The diagonal elements of the tridiagonal matrix T: D(i) = A(i,i).
[out]eREAL 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]tauREAL array, dimension (N-1) The scalar factors of the elementary reflectors (see Further Details).
[out]work(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]lworkINTEGER The dimension of the array WORK. LWORK >= N*NB, where NB is the optimal blocksize given by magma_get_ssytrd_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]infoINTEGER
  • = 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 real scalar, and v is a real 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 real scalar, and v is a real 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).