single precision
[LU solve: computational]

Functions

magma_int_t magma_sgerbt_batched (magma_bool_t gen, magma_int_t n, magma_int_t nrhs, float **dA_array, magma_int_t ldda, float **dB_array, magma_int_t lddb, float *U, float *V, magma_int_t *info, magma_int_t batchCount, magma_queue_t queue)
 Solves a system of linear equations A * X = B where A is a general n-by-n matrix and X and B are n-by-nrhs matrices.
magma_int_t magma_sgerbt_gpu (magma_bool_t gen, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, float *U, float *V, magma_int_t *info)
 Solves a system of linear equations A * X = B where A is a general n-by-n matrix and X and B are n-by-nrhs matrices.
magma_int_t magma_sgesv_rbt_batched (magma_int_t n, magma_int_t nrhs, float **dA_array, magma_int_t ldda, float **dB_array, magma_int_t lddb, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
 Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.
magma_int_t magma_sgetrf (magma_int_t m, magma_int_t n, float *A, magma_int_t lda, magma_int_t *ipiv, magma_int_t *info)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf2_mgpu (magma_int_t ngpu, magma_int_t m, magma_int_t n, magma_int_t nb, magma_int_t offset, magmaFloat_ptr d_lAT[], magma_int_t lddat, magma_int_t *ipiv, magmaFloat_ptr d_lAP[], float *W, magma_int_t ldw, magma_queue_t queues[][2], magma_int_t *info)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_batched (magma_int_t m, magma_int_t n, float **dA_array, magma_int_t ldda, magma_int_t **ipiv_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_gpu (magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magma_int_t *info)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_m (magma_int_t ngpu, magma_int_t m, magma_int_t n, float *A, magma_int_t lda, magma_int_t *ipiv, magma_int_t *info)
 SGETRF_m computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_mgpu (magma_int_t ngpu, magma_int_t m, magma_int_t n, magmaFloat_ptr d_lA[], magma_int_t ldda, magma_int_t *ipiv, magma_int_t *info)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_nopiv (magma_int_t m, magma_int_t n, float *A, magma_int_t lda, magma_int_t *info)
 SGETRF_NOPIV computes an LU factorization of a general M-by-N matrix A without pivoting.
magma_int_t magma_sgetrf_nopiv_batched (magma_int_t m, magma_int_t n, float **dA_array, magma_int_t lda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
 SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.
magma_int_t magma_sgetrf_nopiv_gpu (magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *info)
 SGETRF_NOPIV_GPU computes an LU factorization of a general M-by-N matrix A without any pivoting.
magma_int_t magma_sgetri_gpu (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magmaFloat_ptr dwork, magma_int_t lwork, magma_int_t *info)
 SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF.
magma_int_t magma_sgetri_outofplace_batched (magma_int_t n, float **dA_array, magma_int_t ldda, magma_int_t **dipiv_array, float **dinvA_array, magma_int_t lddia, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
 SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF.
magma_int_t magma_sgetrs_batched (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, float **dA_array, magma_int_t ldda, magma_int_t **dipiv_array, float **dB_array, magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue)
 Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.
magma_int_t magma_sgetrs_gpu (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magmaFloat_ptr dB, magma_int_t lddb, magma_int_t *info)
 Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.
magma_int_t magma_sgetrs_nopiv_batched (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, float **dA_array, magma_int_t ldda, float **dB_array, magma_int_t lddb, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue)
 Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.
magma_int_t magma_sgetrs_nopiv_gpu (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaFloat_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_int_t *info)
 Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_NOPIV_GPU.

Function Documentation

magma_int_t magma_sgerbt_batched ( magma_bool_t  gen,
magma_int_t  n,
magma_int_t  nrhs,
float **  dA_array,
magma_int_t  ldda,
float **  dB_array,
magma_int_t  lddb,
float *  U,
float *  V,
magma_int_t *  info,
magma_int_t  batchCount,
magma_queue_t  queue 
)

Solves a system of linear equations A * X = B where A is a general n-by-n matrix and X and B are n-by-nrhs matrices.

Random Butterfly Tranformation is applied on A and B, then the LU decomposition with no pivoting is used to factor A as A = L * U, where L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Parameters:
[in] gen magma_bool_t

  • = MagmaTrue: new matrices are generated for U and V
  • = MagmaFalse: matrices U and V given as parameter are used
[in] n INTEGER The order of the matrix A. n >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. nrhs >= 0.
[in,out] dA REAL array, dimension (LDA,n). On entry, the M-by-n matrix to be factored. On exit, the factors L and U from the factorization A = L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,n).
[in,out] dB REAL array, dimension (LDB,nrhs) On entry, the right hand side matrix B. On exit, the solution matrix X.
[in] lddb INTEGER The leading dimension of the array B. LDB >= max(1,n).
[in,out] U REAL array, dimension (2,n) Random butterfly matrix, if gen = MagmaTrue U is generated and returned as output; else we use U given as input. CPU memory
[in,out] V REAL array, dimension (2,n) Random butterfly matrix, if gen = MagmaTrue V is generated and returned as output; else we use U given as input. CPU memory
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
magma_int_t magma_sgerbt_gpu ( magma_bool_t  gen,
magma_int_t  n,
magma_int_t  nrhs,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magmaFloat_ptr  dB,
magma_int_t  lddb,
float *  U,
float *  V,
magma_int_t *  info 
)

Solves a system of linear equations A * X = B where A is a general n-by-n matrix and X and B are n-by-nrhs matrices.

Random Butterfly Tranformation is applied on A and B, then the LU decomposition with no pivoting is used to factor A as A = L * U, where L is unit lower triangular, and U is upper triangular. The factored form of A is then used to solve the system of equations A * X = B.

Parameters:
[in] gen magma_bool_t

  • = MagmaTrue: new matrices are generated for U and V
  • = MagmaFalse: matrices U and V given as parameter are used
[in] n INTEGER The order of the matrix A. n >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. nrhs >= 0.
[in,out] dA REAL array, dimension (LDA,n). On entry, the M-by-n matrix to be factored. On exit, the factors L and U from the factorization A = L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,n).
[in,out] dB REAL array, dimension (LDB,nrhs) On entry, the right hand side matrix B. On exit, the solution matrix X.
[in] lddb INTEGER The leading dimension of the array B. LDB >= max(1,n).
[in,out] U REAL array, dimension (2,n) Random butterfly matrix, if gen = MagmaTrue U is generated and returned as output; else we use U given as input. CPU memory
[in,out] V REAL array, dimension (2,n) Random butterfly matrix, if gen = MagmaTrue V is generated and returned as output; else we use U given as input. CPU memory
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
magma_int_t magma_sgesv_rbt_batched ( magma_int_t  n,
magma_int_t  nrhs,
float **  dA_array,
magma_int_t  ldda,
float **  dB_array,
magma_int_t  lddb,
magma_int_t *  info_array,
magma_int_t  batchCount,
magma_queue_t  queue 
)

Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.

Parameters:
[in] trans magma_trans_t Specifies the form of the system of equations:

  • = MagmaNoTrans: A * X = B (No transpose)
  • = MagmaTrans: A**T * X = B (Transpose)
  • = MagmaConjTrans: A**H * X = B (Conjugate transpose)
[in] n INTEGER The order of the matrix A. N >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in] dA REAL array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[in,out] dB REAL array on the GPU, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.
[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_sgetrf ( magma_int_t  m,
magma_int_t  n,
float *  A,
magma_int_t  lda,
magma_int_t *  ipiv,
magma_int_t *  info 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

This version does not require work space on the GPU passed as input. GPU memory is allocated in the routine.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

If the current stream is NULL, this version replaces it with a new stream to overlap computation with communication.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] A REAL array, dimension (LDA,N) On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
Higher performance is achieved if A is in pinned memory, e.g. allocated using magma_malloc_pinned.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf2_mgpu ( magma_int_t  ngpu,
magma_int_t  m,
magma_int_t  n,
magma_int_t  nb,
magma_int_t  offset,
magmaFloat_ptr  d_lAT[],
magma_int_t  lddat,
magma_int_t *  ipiv,
magmaFloat_ptr  d_lAP[],
float *  W,
magma_int_t  ldw,
magma_queue_t  queues[][2],
magma_int_t *  info 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm. Use two buffer to send panels.

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] d_lAT REAL array of pointers on the GPU, dimension (ngpu). On entry, the M-by-N matrix A distributed over GPUs (d_lAT[d] points to the local matrix on d-th GPU). It uses a 1D block column cyclic format (with the block size nb), and each local matrix is stored by row. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] lddat INTEGER The leading dimension of the array d_lAT[d]. LDDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
(workspace) on device d_lAP REAL array of pointers on the GPU, dimension (ngpu). d_lAP[d] is the workspace on d-th GPU. Each local workspace must be of size (3+ngpu)*nb*maxm, where maxm is m rounded up to a multiple of 32 and nb is the block size.
(workspace) W REAL array, dimension (ngpu*nb*maxm). It is used to store panel on CPU.
[in] ldw INTEGER The leading dimension of the workspace w.
[in] queues magma_queue_t queues[d] points to the streams for the d-th GPU to execute in. Each GPU require two streams.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_batched ( magma_int_t  m,
magma_int_t  n,
float **  dA_array,
magma_int_t  ldda,
magma_int_t **  ipiv_array,
magma_int_t *  info_array,
magma_int_t  batchCount,
magma_queue_t  queue 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

If the current stream is NULL, this version replaces it with a new stream to overlap computation with communication.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N). On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_gpu ( magma_int_t  m,
magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magma_int_t *  ipiv,
magma_int_t *  info 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

If the current stream is NULL, this version replaces it with a new stream to overlap computation with communication.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N). On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_m ( magma_int_t  ngpu,
magma_int_t  m,
magma_int_t  n,
float *  A,
magma_int_t  lda,
magma_int_t *  ipiv,
magma_int_t *  info 
)

SGETRF_m computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

This version does not require work space on the GPU passed as input. GPU memory is allocated in the routine. The matrix may exceed the GPU memory.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

Note: The factorization of big panel is done calling multiple-gpu-interface. Pivots are applied on GPU within the big panel.

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] A REAL array, dimension (LDA,N) On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
Higher performance is achieved if A is in pinned memory, e.g. allocated using magma_malloc_pinned.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_mgpu ( magma_int_t  ngpu,
magma_int_t  m,
magma_int_t  n,
magmaFloat_ptr  d_lA[],
magma_int_t  ldda,
magma_int_t *  ipiv,
magma_int_t *  info 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

Parameters:
[in] ngpu INTEGER Number of GPUs to use. ngpu > 0.
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] d_lA REAL array of pointers on the GPU, dimension (ngpu). On entry, the M-by-N matrix A distributed over GPUs (d_lA[d] points to the local matrix on d-th GPU). It uses 1D block column cyclic format with the block size of nb, and each local matrix is stored by column. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array d_lA. LDDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_nopiv ( magma_int_t  m,
magma_int_t  n,
float *  A,
magma_int_t  lda,
magma_int_t *  info 
)

SGETRF_NOPIV computes an LU factorization of a general M-by-N matrix A without pivoting.

The factorization has the form A = L * U where L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] A REAL array, dimension (LDA,N) On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] lda INTEGER The leading dimension of the array A. LDA >= max(1,M).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_nopiv_batched ( magma_int_t  m,
magma_int_t  n,
float **  dA_array,
magma_int_t  lda,
magma_int_t *  info_array,
magma_int_t  batchCount,
magma_queue_t  queue 
)

SGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

If the current stream is NULL, this version replaces it with a new stream to overlap computation with communication.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N). On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,M).
[out] ipiv INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetrf_nopiv_gpu ( magma_int_t  m,
magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magma_int_t *  info 
)

SGETRF_NOPIV_GPU computes an LU factorization of a general M-by-N matrix A without any pivoting.

The factorization has the form A = P * L * U where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

Parameters:
[in] m INTEGER The number of rows of the matrix A. M >= 0.
[in] n INTEGER The number of columns of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N). On entry, the M-by-N matrix to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,M).
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value or another error occured, such as memory allocation failed.
  • > 0: if INFO = i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.
magma_int_t magma_sgetri_gpu ( magma_int_t  n,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magma_int_t *  ipiv,
magmaFloat_ptr  dwork,
magma_int_t  lwork,
magma_int_t *  info 
)

SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF.

This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

Note that it is generally both faster and more accurate to use SGESV, or SGETRF and SGETRS, to solve the system AX = B, rather than inverting the matrix and multiplying to form X = inv(A)*B. Only in special instances should an explicit inverse be computed with this routine.

Parameters:
[in] n INTEGER The order of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N) On entry, the factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU. On exit, if INFO = 0, the inverse of the original matrix A.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[out] dwork (workspace) REAL array on the GPU, dimension (MAX(1,LWORK))
[in] lwork INTEGER The dimension of the array DWORK. LWORK >= N*NB, where NB is the optimal blocksize returned by magma_get_sgetri_nb(n).
Unlike LAPACK, this version does not currently support a workspace query, because the workspace is on the GPU.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
  • > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its cannot be computed.
magma_int_t magma_sgetri_outofplace_batched ( magma_int_t  n,
float **  dA_array,
magma_int_t  ldda,
magma_int_t **  dipiv_array,
float **  dinvA_array,
magma_int_t  lddia,
magma_int_t *  info_array,
magma_int_t  batchCount,
magma_queue_t  queue 
)

SGETRI computes the inverse of a matrix using the LU factorization computed by SGETRF.

This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A).

Note that it is generally both faster and more accurate to use SGESV, or SGETRF and SGETRS, to solve the system AX = B, rather than inverting the matrix and multiplying to form X = inv(A)*B. Only in special instances should an explicit inverse be computed with this routine.

Parameters:
[in] n INTEGER The order of the matrix A. N >= 0.
[in,out] dA REAL array on the GPU, dimension (LDDA,N) On entry, the factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU. On exit, if INFO = 0, the inverse of the original matrix A.
[in] ldda INTEGER The leading dimension of the array A. LDDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[out] dwork (workspace) REAL array on the GPU, dimension (MAX(1,LWORK))
[in] lwork INTEGER The dimension of the array DWORK. LWORK >= N*NB, where NB is the optimal blocksize returned by magma_get_sgetri_nb(n).
Unlike LAPACK, this version does not currently support a workspace query, because the workspace is on the GPU.
[out] info INTEGER

  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
  • > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its cannot be computed.
magma_int_t magma_sgetrs_batched ( magma_trans_t  trans,
magma_int_t  n,
magma_int_t  nrhs,
float **  dA_array,
magma_int_t  ldda,
magma_int_t **  dipiv_array,
float **  dB_array,
magma_int_t  lddb,
magma_int_t  batchCount,
magma_queue_t  queue 
)

Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.

Parameters:
[in] trans magma_trans_t Specifies the form of the system of equations:

  • = MagmaNoTrans: A * X = B (No transpose)
  • = MagmaTrans: A**T * X = B (Transpose)
  • = MagmaConjTrans: A**H * X = B (Conjugate transpose)
[in] n INTEGER The order of the matrix A. N >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in] dA REAL array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[in,out] dB REAL array on the GPU, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.
[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_sgetrs_gpu ( magma_trans_t  trans,
magma_int_t  n,
magma_int_t  nrhs,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magma_int_t *  ipiv,
magmaFloat_ptr  dB,
magma_int_t  lddb,
magma_int_t *  info 
)

Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.

Parameters:
[in] trans magma_trans_t Specifies the form of the system of equations:

  • = MagmaNoTrans: A * X = B (No transpose)
  • = MagmaTrans: A**T * X = B (Transpose)
  • = MagmaConjTrans: A**H * X = B (Conjugate transpose)
[in] n INTEGER The order of the matrix A. N >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in] dA REAL array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[in,out] dB REAL array on the GPU, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.
[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_sgetrs_nopiv_batched ( magma_trans_t  trans,
magma_int_t  n,
magma_int_t  nrhs,
float **  dA_array,
magma_int_t  ldda,
float **  dB_array,
magma_int_t  lddb,
magma_int_t *  info_array,
magma_int_t  batchCount,
magma_queue_t  queue 
)

Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_GPU.

Parameters:
[in] trans magma_trans_t Specifies the form of the system of equations:

  • = MagmaNoTrans: A * X = B (No transpose)
  • = MagmaTrans: A**T * X = B (Transpose)
  • = MagmaConjTrans: A**H * X = B (Conjugate transpose)
[in] n INTEGER The order of the matrix A. N >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in] dA REAL array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in] ipiv INTEGER array, dimension (N) The pivot indices from SGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i).
[in,out] dB REAL array on the GPU, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.
[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_sgetrs_nopiv_gpu ( magma_trans_t  trans,
magma_int_t  n,
magma_int_t  nrhs,
magmaFloat_ptr  dA,
magma_int_t  ldda,
magmaFloat_ptr  dB,
magma_int_t  lddb,
magma_int_t *  info 
)

Solves a system of linear equations A * X = B, A**T * X = B, or A**H * X = B with a general N-by-N matrix A using the LU factorization computed by SGETRF_NOPIV_GPU.

Parameters:
[in] trans magma_trans_t Specifies the form of the system of equations:

  • = MagmaNoTrans: A * X = B (No transpose)
  • = MagmaTrans: A**T * X = B (Transpose)
  • = MagmaConjTrans: A**H * X = B (Conjugate transpose)
[in] n INTEGER The order of the matrix A. N >= 0.
[in] nrhs INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in] dA REAL array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by SGETRF_GPU.
[in] ldda INTEGER The leading dimension of the array A. LDA >= max(1,N).

param[in,out] dB REAL array on the GPU, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X.

Parameters:
[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

Generated on 3 May 2015 for MAGMA by  doxygen 1.6.1