Functions | |
magma_int_t | magma_zcgetrs_gpu (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaInt_ptr dipiv, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex_ptr dX, magma_int_t lddx, magmaFloatComplex_ptr dSX, magma_int_t *info) |
ZCGETRS 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 MAGMA_CGETRF_GPU. | |
magma_int_t | magma_zgerbt_batched (magma_bool_t gen, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **dB_array, magma_int_t lddb, magmaDoubleComplex *U, magmaDoubleComplex *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_zgerbt_gpu (magma_bool_t gen, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex *U, magmaDoubleComplex *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_zgesv_rbt_batched (magma_int_t n, magma_int_t nrhs, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **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 ZGETRF_GPU. | |
magma_int_t | magma_zgetrf (magma_int_t m, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magma_int_t *ipiv, magma_int_t *info) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf2_mgpu (magma_int_t ngpu, magma_int_t m, magma_int_t n, magma_int_t nb, magma_int_t offset, magmaDoubleComplex_ptr d_lAT[], magma_int_t lddat, magma_int_t *ipiv, magmaDoubleComplex_ptr d_lAP[], magmaDoubleComplex *W, magma_int_t ldw, magma_queue_t queues[][2], magma_int_t *info) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_batched (magma_int_t m, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, magma_int_t **ipiv_array, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_gpu (magma_int_t m, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magma_int_t *info) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_m (magma_int_t ngpu, magma_int_t m, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magma_int_t *ipiv, magma_int_t *info) |
ZGETRF_m computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_mgpu (magma_int_t ngpu, magma_int_t m, magma_int_t n, magmaDoubleComplex_ptr d_lA[], magma_int_t ldda, magma_int_t *ipiv, magma_int_t *info) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_nopiv (magma_int_t m, magma_int_t n, magmaDoubleComplex *A, magma_int_t lda, magma_int_t *info) |
ZGETRF_NOPIV computes an LU factorization of a general M-by-N matrix A without pivoting. | |
magma_int_t | magma_zgetrf_nopiv_batched (magma_int_t m, magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t lda, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) |
ZGETRF computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges. | |
magma_int_t | magma_zgetrf_nopiv_gpu (magma_int_t m, magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_int_t *info) |
ZGETRF_NOPIV_GPU computes an LU factorization of a general M-by-N matrix A without any pivoting. | |
magma_int_t | magma_zgetri_gpu (magma_int_t n, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magmaDoubleComplex_ptr dwork, magma_int_t lwork, magma_int_t *info) |
ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF. | |
magma_int_t | magma_zgetri_outofplace_batched (magma_int_t n, magmaDoubleComplex **dA_array, magma_int_t ldda, magma_int_t **dipiv_array, magmaDoubleComplex **dinvA_array, magma_int_t lddia, magma_int_t *info_array, magma_int_t batchCount, magma_queue_t queue) |
ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF. | |
magma_int_t | magma_zgetrs_batched (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex **dA_array, magma_int_t ldda, magma_int_t **dipiv_array, magmaDoubleComplex **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 ZGETRF_GPU. | |
magma_int_t | magma_zgetrs_gpu (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magma_int_t *ipiv, magmaDoubleComplex_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 ZGETRF_GPU. | |
magma_int_t | magma_zgetrs_nopiv_batched (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex **dA_array, magma_int_t ldda, magmaDoubleComplex **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 ZGETRF_GPU. | |
magma_int_t | magma_zgetrs_nopiv_gpu (magma_trans_t trans, magma_int_t n, magma_int_t nrhs, magmaDoubleComplex_ptr dA, magma_int_t ldda, magmaDoubleComplex_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 ZGETRF_NOPIV_GPU. |
magma_int_t magma_zcgetrs_gpu | ( | magma_trans_t | trans, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaFloatComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magmaInt_ptr | dipiv, | |||
magmaDoubleComplex_ptr | dB, | |||
magma_int_t | lddb, | |||
magmaDoubleComplex_ptr | dX, | |||
magma_int_t | lddx, | |||
magmaFloatComplex_ptr | dSX, | |||
magma_int_t * | info | |||
) |
ZCGETRS 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 MAGMA_CGETRF_GPU.
B and X are in COMPLEX_16, and A is in COMPLEX. This routine is used in the mixed precision iterative solver magma_zcgesv.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX array on the GPU, dimension (LDDA,N) The factors L and U from the factorization A = P*L*U as computed by CGETRF_GPU. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,N). |
[in] | dipiv | INTEGER array on the GPU, dimension (N) The pivot indices; for 1 <= i <= N, after permuting, row i of the matrix was moved to row dIPIV(i). Note this is different than IPIV from ZGETRF, where interchanges are applied one-after-another. |
[in] | dB | COMPLEX_16 array on the GPU, dimension (LDDB,NRHS) On entry, the right hand side matrix B. |
[in] | lddb | INTEGER The leading dimension of the arrays X and B. LDDB >= max(1,N). |
[out] | dX | COMPLEX_16 array on the GPU, dimension (LDDX, NRHS) On exit, the solution matrix dX. |
[in] | lddx | INTEGER The leading dimension of the array dX, LDDX >= max(1,N). |
dSX | (workspace) COMPLEX array on the GPU used as workspace, dimension (N, NRHS) | |
[out] | info | INTEGER
|
magma_int_t magma_zgerbt_batched | ( | magma_bool_t | gen, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magmaDoubleComplex ** | dB_array, | |||
magma_int_t | lddb, | |||
magmaDoubleComplex * | U, | |||
magmaDoubleComplex * | 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.
[in] | gen | magma_bool_t
|
[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 | COMPLEX_16 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 | COMPLEX_16 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 | COMPLEX_16 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 | COMPLEX_16 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
|
magma_int_t magma_zgerbt_gpu | ( | magma_bool_t | gen, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magmaDoubleComplex_ptr | dB, | |||
magma_int_t | lddb, | |||
magmaDoubleComplex * | U, | |||
magmaDoubleComplex * | 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.
[in] | gen | magma_bool_t
|
[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 | COMPLEX_16 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 | COMPLEX_16 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 | COMPLEX_16 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 | COMPLEX_16 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
|
magma_int_t magma_zgesv_rbt_batched | ( | magma_int_t | n, | |
magma_int_t | nrhs, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magmaDoubleComplex ** | 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 ZGETRF_GPU.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX_16 array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[in,out] | dB | COMPLEX_16 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
|
magma_int_t magma_zgetrf | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | ipiv, | |||
magma_int_t * | info | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf2_mgpu | ( | magma_int_t | ngpu, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
magma_int_t | nb, | |||
magma_int_t | offset, | |||
magmaDoubleComplex_ptr | d_lAT[], | |||
magma_int_t | lddat, | |||
magma_int_t * | ipiv, | |||
magmaDoubleComplex_ptr | d_lAP[], | |||
magmaDoubleComplex * | W, | |||
magma_int_t | ldw, | |||
magma_queue_t | queues[][2], | |||
magma_int_t * | info | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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 COMPLEX_16 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 COMPLEX_16 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
|
magma_int_t magma_zgetrf_batched | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magma_int_t ** | ipiv_array, | |||
magma_int_t * | info_array, | |||
magma_int_t | batchCount, | |||
magma_queue_t | queue | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_gpu | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | ipiv, | |||
magma_int_t * | info | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_m | ( | magma_int_t | ngpu, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
magmaDoubleComplex * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | ipiv, | |||
magma_int_t * | info | |||
) |
ZGETRF_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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_mgpu | ( | magma_int_t | ngpu, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
magmaDoubleComplex_ptr | d_lA[], | |||
magma_int_t | ldda, | |||
magma_int_t * | ipiv, | |||
magma_int_t * | info | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_nopiv | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | info | |||
) |
ZGETRF_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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_nopiv_batched | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | lda, | |||
magma_int_t * | info_array, | |||
magma_int_t | batchCount, | |||
magma_queue_t | queue | |||
) |
ZGETRF 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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetrf_nopiv_gpu | ( | magma_int_t | m, | |
magma_int_t | n, | |||
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | info | |||
) |
ZGETRF_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.
[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 | COMPLEX_16 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
|
magma_int_t magma_zgetri_gpu | ( | magma_int_t | n, | |
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | ipiv, | |||
magmaDoubleComplex_ptr | dwork, | |||
magma_int_t | lwork, | |||
magma_int_t * | info | |||
) |
ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF.
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 ZGESV, or ZGETRF and ZGETRS, 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.
[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 factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[out] | dwork | (workspace) COMPLEX_16 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_zgetri_nb(n). Unlike LAPACK, this version does not currently support a workspace query, because the workspace is on the GPU. |
[out] | info | INTEGER
|
magma_int_t magma_zgetri_outofplace_batched | ( | magma_int_t | n, | |
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magma_int_t ** | dipiv_array, | |||
magmaDoubleComplex ** | dinvA_array, | |||
magma_int_t | lddia, | |||
magma_int_t * | info_array, | |||
magma_int_t | batchCount, | |||
magma_queue_t | queue | |||
) |
ZGETRI computes the inverse of a matrix using the LU factorization computed by ZGETRF.
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 ZGESV, or ZGETRF and ZGETRS, 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.
[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 factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[out] | dwork | (workspace) COMPLEX_16 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_zgetri_nb(n). Unlike LAPACK, this version does not currently support a workspace query, because the workspace is on the GPU. |
[out] | info | INTEGER
|
magma_int_t magma_zgetrs_batched | ( | magma_trans_t | trans, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magma_int_t ** | dipiv_array, | |||
magmaDoubleComplex ** | 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 ZGETRF_GPU.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX_16 array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[in,out] | dB | COMPLEX_16 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
|
magma_int_t magma_zgetrs_gpu | ( | magma_trans_t | trans, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | ipiv, | |||
magmaDoubleComplex_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 ZGETRF_GPU.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX_16 array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[in,out] | dB | COMPLEX_16 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
|
magma_int_t magma_zgetrs_nopiv_batched | ( | magma_trans_t | trans, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex ** | dA_array, | |||
magma_int_t | ldda, | |||
magmaDoubleComplex ** | 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 ZGETRF_GPU.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX_16 array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by ZGETRF_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 ZGETRF; for 1 <= i <= N, row i of the matrix was interchanged with row IPIV(i). |
[in,out] | dB | COMPLEX_16 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
|
magma_int_t magma_zgetrs_nopiv_gpu | ( | magma_trans_t | trans, | |
magma_int_t | n, | |||
magma_int_t | nrhs, | |||
magmaDoubleComplex_ptr | dA, | |||
magma_int_t | ldda, | |||
magmaDoubleComplex_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 ZGETRF_NOPIV_GPU.
[in] | trans | magma_trans_t Specifies the form of the system of equations:
|
[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 | COMPLEX_16 array on the GPU, dimension (LDA,N) The factors L and U from the factorization A = P*L*U as computed by ZGETRF_GPU. |
[in] | ldda | INTEGER The leading dimension of the array A. LDA >= max(1,N). |
param[in,out] dB COMPLEX_16 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
|