![]() |
MAGMA
2.0.0
Matrix Algebra for GPU and Multicore Architectures
|
Functions | |
magma_int_t | magma_snan_inf (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const float *A, magma_int_t lda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_snan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values. More... | |
magma_int_t | magma_snan_inf_gpu (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_snan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values. More... | |
void | magma_sprint (magma_int_t m, magma_int_t n, const float *A, magma_int_t lda) |
magma_sprint prints a matrix that is located on the CPU host. More... | |
void | magma_sprint_gpu (magma_int_t m, magma_int_t n, const float *dA, magma_int_t ldda) |
magma_sprint_gpu prints a matrix that is located on the GPU device. More... | |
void | magmablas_sgeadd_q (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue) |
ZGEADD adds two matrices, dB = alpha*dA + dB. More... | |
void | magmablas_sgeadd (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb) |
void | magmablas_sgeadd2_q (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, float beta, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue) |
ZGEADD2 adds two matrices, dB = alpha*dA + beta*dB. More... | |
void | magmablas_sgeadd2 (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, float beta, magmaFloat_ptr dB, magma_int_t lddb) |
void | magmablas_sgeadd_batched_q (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr const dAarray[], magma_int_t ldda, magmaFloat_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue) |
ZGEADD adds two sets of matrices, dAarray[i] = alpha*dAarray[i] + dBarray[i], for i = 0, ..., batchCount-1. More... | |
void | magmablas_sgeadd_batched (magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr const dAarray[], magma_int_t ldda, magmaFloat_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount) |
void | magmablas_slacpy_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue) |
SLACPY copies all or part of a two-dimensional matrix dA to another matrix dB. More... | |
void | magmablas_slacpy (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb) |
void | magmablas_slacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloat_const_ptr const dAarray[], magma_int_t ldda, magmaFloat_ptr dBarray[], magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue) |
SLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount. More... | |
void | magmablas_slacpy_sym_in_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t *rows, magma_int_t *perm, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue) |
SLACPY_Q copies all or part of a two-dimensional matrix dA to another matrix dB. More... | |
void | magmablas_slacpy_sym_in (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t *rows, magma_int_t *perm, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb) |
void | magmablas_slacpy_sym_out_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t *rows, magma_int_t *perm, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue) |
SLACPY_Q copies all or part of a two-dimensional matrix dA to another matrix dB. More... | |
void | magmablas_slacpy_sym_out (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t *rows, magma_int_t *perm, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb) |
void | magmablas_slag2d_q (magma_int_t m, magma_int_t n, magmaFloat_const_ptr SA, magma_int_t ldsa, magmaDouble_ptr A, magma_int_t lda, magma_queue_t queue, magma_int_t *info) |
SLAG2D converts a single-real matrix, SA, to a double-real matrix, A. More... | |
void | magmablas_slag2d (magma_int_t m, magma_int_t n, magmaFloat_const_ptr SA, magma_int_t ldsa, magmaDouble_ptr A, magma_int_t lda, magma_int_t *info) |
float | magmablas_slange_q (magma_norm_t norm, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dwork, magma_int_t lwork, magma_queue_t queue) |
SLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A. More... | |
float | magmablas_slange (magma_norm_t norm, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dwork, magma_int_t lwork) |
float | magmablas_slansy_q (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dwork, magma_int_t lwork, magma_queue_t queue) |
SLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A. More... | |
float | magmablas_slansy (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dwork, magma_int_t lwork) |
void | magmablas_slascl_q (magma_type_t type, magma_int_t kl, magma_int_t ku, float cfrom, float cto, magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue, magma_int_t *info) |
SLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. More... | |
void | magmablas_slascl (magma_type_t type, magma_int_t kl, magma_int_t ku, float cfrom, float cto, magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_slascl2_q (magma_type_t type, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dD, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue, magma_int_t *info) |
SLASCL2 scales the M by N real matrix A by the real diagonal matrix dD. More... | |
void | magmablas_slascl2 (magma_type_t type, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dD, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_slascl_2x2_q (magma_type_t type, magma_int_t m, magmaFloat_const_ptr dW, magma_int_t lddw, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue, magma_int_t *info) |
SLASCL_2x2 scales the M by M real matrix A by the 2-by-2 pivot. More... | |
void | magmablas_slascl_2x2 (magma_type_t type, magma_int_t m, magmaFloat_const_ptr dW, magma_int_t lddw, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_slascl_diag_q (magma_type_t type, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dD, magma_int_t lddd, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue, magma_int_t *info) |
SLASCL_DIAG scales the M by N real matrix A by the real diagonal matrix dD. More... | |
void | magmablas_slascl_diag (magma_type_t type, magma_int_t m, magma_int_t n, magmaFloat_const_ptr dD, magma_int_t lddd, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_slaset_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, float offdiag, float diag, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue) |
SLASET initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals. More... | |
void | magmablas_slaset (magma_uplo_t uplo, magma_int_t m, magma_int_t n, float offdiag, float diag, magmaFloat_ptr dA, magma_int_t ldda) |
void | magmablas_slaset_band_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, float offdiag, float diag, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue) |
SLASET_BAND initializes the main diagonal of dA to DIAG, and the K-1 sub- or super-diagonals to OFFDIAG. More... | |
void | magmablas_slaset_band (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, float offdiag, float diag, magmaFloat_ptr dA, magma_int_t ldda) |
void | magmablas_slaswp_q (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue) |
Purpose:SLASWP performs a series of row interchanges on the matrix A. More... | |
void | magmablas_slaswp (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci) |
void | magmablas_slaswpx_q (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue) |
Purpose:SLASWPX performs a series of row interchanges on the matrix A. More... | |
void | magmablas_slaswpx (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldx, magma_int_t ldy, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci) |
void | magmablas_slaswp2_q (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci, magma_queue_t queue) |
Purpose:SLASWP2 performs a series of row interchanges on the matrix A. More... | |
void | magmablas_slaswp2 (magma_int_t n, magmaFloat_ptr dAT, magma_int_t ldda, magma_int_t k1, magma_int_t k2, magmaInt_const_ptr d_ipiv, magma_int_t inci) |
void | magmablas_slaswp_sym_q (magma_int_t n, float *dA, magma_int_t lda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci, magma_queue_t queue) |
Purpose:SLASWPX performs a series of row interchanges on the matrix A. More... | |
void | magmablas_slaswp_sym (magma_int_t n, float *dA, magma_int_t lda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci) |
void | magmablas_sswapdblk_q (magma_int_t n, magma_int_t nb, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t inca, magmaFloat_ptr dB, magma_int_t lddb, magma_int_t incb, magma_queue_t queue) |
sswapdblk swaps diagonal blocks of size nb x nb between matrices dA and dB on the GPU. More... | |
void | magmablas_sswapdblk (magma_int_t n, magma_int_t nb, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t inca, magmaFloat_ptr dB, magma_int_t lddb, magma_int_t incb) |
void | magmablas_sswapdblk_batched_q (magma_int_t n, magma_int_t nb, float **dA_array, magma_int_t ldda, magma_int_t inca, float **dB_array, magma_int_t lddb, magma_int_t incb, magma_int_t batchCount, magma_queue_t queue) |
sswapdblk swaps diagonal blocks of size nb x nb between matrices dA and dB on the GPU. More... | |
void | magmablas_sswapdblk_batched (magma_int_t n, magma_int_t nb, float **dA_array, magma_int_t ldda, magma_int_t inca, float **dB_array, magma_int_t lddb, magma_int_t incb, magma_int_t batchCount) |
void | magmablas_ssymmetrize_q (magma_uplo_t uplo, magma_int_t m, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue) |
SSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix. More... | |
void | magmablas_ssymmetrize (magma_uplo_t uplo, magma_int_t m, magmaFloat_ptr dA, magma_int_t ldda) |
void | magmablas_ssymmetrize_tiles_q (magma_uplo_t uplo, magma_int_t m, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride, magma_queue_t queue) |
SSYMMETRIZE_TILES copies lower triangle to upper triangle, or vice-versa, to make some blocks of dA into general representations of a symmetric block. More... | |
void | magmablas_ssymmetrize_tiles (magma_uplo_t uplo, magma_int_t m, magmaFloat_ptr dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride) |
void | magmablas_stranspose_q (magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dAT, magma_int_t lddat, magma_queue_t queue) |
stranspose_q copies and transposes a matrix dA to matrix dAT. More... | |
void | magmablas_stranspose (magma_int_t m, magma_int_t n, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dAT, magma_int_t lddat) |
void | magmablas_stranspose_batched_q (magma_int_t m, magma_int_t n, float **dA_array, magma_int_t ldda, float **dAT_array, magma_int_t lddat, magma_int_t batchCount, magma_queue_t queue) |
stranspose_batched_q copies and transposes a matrix dA_array[i] to matrix dAT_array[i]. More... | |
void | magmablas_stranspose_batched (magma_int_t m, magma_int_t n, float **dA_array, magma_int_t ldda, float **dAT_array, magma_int_t lddat, magma_int_t batchCount) |
void | magmablas_stranspose_inplace_q (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magma_queue_t queue) |
stranspose_inplace_q transposes a square N-by-N matrix in-place. More... | |
void | magmablas_stranspose_inplace (magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda) |
magma_int_t magma_snan_inf | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const float * | A, | ||
magma_int_t | lda, | ||
magma_int_t * | cnt_nan, | ||
magma_int_t * | cnt_inf | ||
) |
magma_snan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values.
NAN is created by 0/0 and similar. INF is created by x/0 and similar, where x != 0.
[in] | uplo | magma_uplo_t Specifies what part of the matrix A to check.
|
[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] | A | REAL array, dimension (LDA,N), on the CPU host. The M-by-N matrix to be printed. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,M). |
[out] | cnt_nan | INTEGER* If non-NULL, on exit contains the number of NAN values in A. |
[out] | cnt_inf | INTEGER* If non-NULL, on exit contains the number of INF values in A. |
magma_int_t magma_snan_inf_gpu | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | cnt_nan, | ||
magma_int_t * | cnt_inf | ||
) |
magma_snan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values.
NAN is created by 0/0 and similar. INF is created by x/0 and similar, where x != 0.
[in] | uplo | magma_uplo_t Specifies what part of the matrix A to check.
|
[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] | dA | REAL array, dimension (LDDA,N), on the GPU device. The M-by-N matrix to be printed. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
[out] | cnt_nan | INTEGER* If non-NULL, on exit contains the number of NAN values in A. |
[out] | cnt_inf | INTEGER* If non-NULL, on exit contains the number of INF values in A. |
void magma_sprint | ( | magma_int_t | m, |
magma_int_t | n, | ||
const float * | A, | ||
magma_int_t | lda | ||
) |
magma_sprint prints a matrix that is located on the CPU host.
The output is intended to be Matlab compatible, to be useful in debugging.
[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] | A | REAL array, dimension (LDA,N), on the CPU host. The M-by-N matrix to be printed. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,M). |
void magma_sprint_gpu | ( | magma_int_t | m, |
magma_int_t | n, | ||
const float * | dA, | ||
magma_int_t | ldda | ||
) |
magma_sprint_gpu prints a matrix that is located on the GPU device.
Internally, it allocates CPU memory and copies the matrix to the CPU. The output is intended to be Matlab compatible, to be useful in debugging.
[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] | dA | REAL array, dimension (LDDA,N), on the GPU device. The M-by-N matrix to be printed. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
void magmablas_sgeadd | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb | ||
) |
void magmablas_sgeadd2 | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
float | beta, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb | ||
) |
void magmablas_sgeadd2_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
float | beta, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_queue_t | queue | ||
) |
ZGEADD2 adds two matrices, dB = alpha*dA + beta*dB.
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | alpha | REAL The scalar alpha. |
[in] | dA | REAL array, dimension (LDDA,N) The m by n matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | beta | REAL The scalar beta. |
[in,out] | dB | REAL array, dimension (LDDB,N) The m by n matrix dB. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_sgeadd_batched | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr const | dAarray[], | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dBarray[], | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount | ||
) |
void magmablas_sgeadd_batched_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr const | dAarray[], | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dBarray[], | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount, | ||
magma_queue_t | queue | ||
) |
ZGEADD adds two sets of matrices, dAarray[i] = alpha*dAarray[i] + dBarray[i], for i = 0, ..., batchCount-1.
[in] | m | INTEGER The number of rows of each matrix dAarray[i]. M >= 0. |
[in] | n | INTEGER The number of columns of each matrix dAarray[i]. N >= 0. |
[in] | alpha | REAL The scalar alpha. |
[in] | dAarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a REAL array, dimension (LDDA,N) The m by n matrices dAarray[i]. |
[in] | ldda | INTEGER The leading dimension of each array dAarray[i]. LDDA >= max(1,M). |
[in,out] | dBarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a REAL array, dimension (LDDB,N) The m by n matrices dBarray[i]. |
[in] | lddb | INTEGER The leading dimension of each array dBarray[i]. LDDB >= max(1,M). |
[in] | batchCount | INTEGER The number of matrices to add; length of dAarray and dBarray. batchCount >= 0. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_sgeadd_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
float | alpha, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_queue_t | queue | ||
) |
ZGEADD adds two matrices, dB = alpha*dA + dB.
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | alpha | REAL The scalar alpha. |
[in] | dA | REAL array, dimension (LDDA,N) The m by n matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in,out] | dB | REAL array, dimension (LDDB,N) The m by n matrix dB. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slacpy | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb | ||
) |
void magmablas_slacpy_batched | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr const | dAarray[], | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dBarray[], | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount, | ||
magma_queue_t | queue | ||
) |
SLACPY_BATCHED copies all or part of each two-dimensional matrix dAarray[i] to matrix dBarray[i], for 0 <= i < batchcount.
[in] | uplo | magma_uplo_t Specifies the part of each matrix dA to be copied to dB.
|
[in] | m | INTEGER The number of rows of each matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of each matrix dA. N >= 0. |
[in] | dAarray | REAL* array, dimension (batchCount) Array of pointers to the matrices dA, where each dA is of dimension (LDDA,N). The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. |
[in] | ldda | INTEGER The leading dimension of each array dA. LDDA >= max(1,M). |
[out] | dBarray | REAL* array, dimension (batchCount) Array of pointers to the matrices dB, where each dB is of dimension (LDDB,N). The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO. |
[in] | lddb | INTEGER The leading dimension of each array dB. LDDB >= max(1,M). |
[in] | batchCount | Number of matrices in dAarray and dBarray. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slacpy_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_queue_t | queue | ||
) |
SLACPY copies all or part of a two-dimensional matrix dA to another matrix dB.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA to be copied to dB.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[out] | dB | REAL array, dimension (LDDB,N) The M-by-N matrix dB. On exit, dB = dA in the locations specified by UPLO. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slacpy_sym_in | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t * | rows, | ||
magma_int_t * | perm, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb | ||
) |
void magmablas_slacpy_sym_in_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t * | rows, | ||
magma_int_t * | perm, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_queue_t | queue | ||
) |
SLACPY_Q copies all or part of a two-dimensional matrix dA to another matrix dB.
This is the same as SLACPY, but adds queue argument.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA to be copied to dB.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of rows that are swapped. N >= 0. |
[in] | rows | INTEGER array, on GPU, dimension (2*n) On entry, it stores the new pivots such that rows[i]-th and rows[n+i]-th rows are swapped. |
[in,out] | perm | INTEGER array, on GPU, dimension (m) On entry, it stores the identity permutation array. On exit, it is updated with the new pivots given by rows such that i-th row will be the original perm[i]-th row after the pivots are applied. |
[in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[out] | dB | REAL array, dimension (LDDB,N) On exit, dB = stores the columns after the pivots are applied. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slacpy_sym_out | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t * | rows, | ||
magma_int_t * | perm, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb | ||
) |
void magmablas_slacpy_sym_out_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t * | rows, | ||
magma_int_t * | perm, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_queue_t | queue | ||
) |
SLACPY_Q copies all or part of a two-dimensional matrix dA to another matrix dB.
This is the same as SLACPY, but adds queue argument.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA to be copied to dB.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | rows | INTEGER array, on GPU, dimension (2*n) On entry, it stores the new pivots such that rows[i]-th and rows[n+i]-th rows are swapped. |
[in,out] | perm | INTEGER array, on GPU, dimension (m) On entry, it stores the permutation array such that i-th row will be the original perm[i]-th row after the pivots are applied. On exit, it is restored to be identity permutation. |
[in,out] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. On exit, the matrix after the symmetric pivoting is applied. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | dB | REAL array, dimension (LDDB,N) The M-by-N matrix dB. On entry, dB stores the columns after row pivoting is applied. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slag2d | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloat_const_ptr | SA, | ||
magma_int_t | ldsa, | ||
magmaDouble_ptr | A, | ||
magma_int_t | lda, | ||
magma_int_t * | info | ||
) |
void magmablas_slag2d_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloat_const_ptr | SA, | ||
magma_int_t | ldsa, | ||
magmaDouble_ptr | A, | ||
magma_int_t | lda, | ||
magma_queue_t | queue, | ||
magma_int_t * | info | ||
) |
SLAG2D converts a single-real matrix, SA, to a double-real matrix, A.
Note that while it is possible to overflow while converting from double to single, it is not possible to overflow when converting from single to double.
[in] | m | INTEGER The number of lines of the matrix A. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix A. N >= 0. |
[in] | SA | SINGLE PRECISION array, dimension (LDSA,N) On entry, the M-by-N coefficient matrix SA. |
[in] | ldsa | INTEGER The leading dimension of the array SA. LDSA >= max(1,M). |
[out] | A | DOUBLE PRECISION array, dimension (LDA,N) On exit, the M-by-N coefficient matrix A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,M). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
float magmablas_slange | ( | magma_norm_t | norm, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dwork, | ||
magma_int_t | lwork | ||
) |
float magmablas_slange_q | ( | magma_norm_t | norm, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dwork, | ||
magma_int_t | lwork, | ||
magma_queue_t | queue | ||
) |
SLANGE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real matrix A.
SLANGE returns the value
SLANGE = ( max(abs(A(i,j))), NORM = MagmaMaxNorm ( ( norm1(A), NORM = MagmaOneNorm ( ( normI(A), NORM = MagmaInfNorm ( ( normF(A), NORM = MagmaFrobeniusNorm ** not yet supported
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
[in] | norm | magma_norm_t Specifies the value to be returned in SLANGE as described above. |
[in] | m | INTEGER The number of rows of the matrix A. M >= 0. When M = 0, SLANGE is set to zero. |
[in] | n | INTEGER The number of columns of the matrix A. N >= 0. When N = 0, SLANGE is set to zero. |
[in] | dA | REAL array on the GPU, dimension (LDDA,N) The m by n matrix A. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(M,1). |
dwork | (workspace) REAL array on the GPU, dimension (LWORK). | |
[in] | lwork | INTEGER The dimension of the array WORK. If NORM = MagmaInfNorm or MagmaMaxNorm, LWORK >= max( 1, M ). If NORM = MagmaOneNorm, LWORK >= max( 1, N ). Note this is different than LAPACK, which requires WORK only for NORM = MagmaInfNorm, and does not pass LWORK. |
float magmablas_slansy | ( | magma_norm_t | norm, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dwork, | ||
magma_int_t | lwork | ||
) |
float magmablas_slansy_q | ( | magma_norm_t | norm, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dwork, | ||
magma_int_t | lwork, | ||
magma_queue_t | queue | ||
) |
SLANSY returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a real symmetric matrix A.
SLANSY = ( max(abs(A(i,j))), NORM = MagmaMaxNorm ( ( norm1(A), NORM = MagmaOneNorm ( ( normI(A), NORM = MagmaInfNorm ( ( normF(A), NORM = MagmaFrobeniusNorm ** not yet supported
where norm1 denotes the one norm of a matrix (maximum column sum), normI denotes the infinity norm of a matrix (maximum row sum) and normF denotes the Frobenius norm of a matrix (square root of sum of squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
On error, returns SLANSY < 0: if SLANSY = -i, the i-th argument had an illegal value.
[in] | norm | magma_norm_t Specifies the value to be returned in SLANSY as described above. |
[in] | uplo | magma_uplo_t Specifies whether the upper or lower triangular part of the symmetric matrix A is to be referenced.
|
[in] | n | INTEGER The order of the matrix A. N >= 0. When N = 0, SLANSY is set to zero. |
[in] | dA | REAL array on the GPU, dimension (LDDA,N) 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. Note that the imaginary parts of the diagonal elements need not be set and are assumed to be zero. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(N,1). |
dwork | (workspace) REAL array on the GPU, dimension (MAX(1,LWORK)), where LWORK >= N. NOTE: this is different than LAPACK, where WORK is required only for norm1 and normI. Here max-norm also requires WORK. | |
[in] | lwork | INTEGER The dimension of the array DWORK. LWORK >= max( 1, N ). |
void magmablas_slascl | ( | magma_type_t | type, |
magma_int_t | kl, | ||
magma_int_t | ku, | ||
float | cfrom, | ||
float | cto, | ||
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | info | ||
) |
void magmablas_slascl2 | ( | magma_type_t | type, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dD, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | info | ||
) |
void magmablas_slascl2_q | ( | magma_type_t | type, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dD, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue, | ||
magma_int_t * | info | ||
) |
SLASCL2 scales the M by N real matrix A by the real diagonal matrix dD.
TYPE specifies that A may be full, upper triangular, lower triangular.
[in] | type | magma_type_t TYPE indices the storage type of the input matrix A. = MagmaFull: full matrix. = MagmaLower: lower triangular matrix. = MagmaUpper: upper triangular matrix. Other formats that LAPACK supports, MAGMA does not currently support. |
[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] | dD | REAL vector, dimension (M) The diagonal matrix containing the scalar factors. Stored as a vector. |
[in,out] | dA | REAL array, dimension (LDDA,N) The matrix to be scaled by dD. See TYPE for the storage type. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slascl_2x2 | ( | magma_type_t | type, |
magma_int_t | m, | ||
magmaFloat_const_ptr | dW, | ||
magma_int_t | lddw, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | info | ||
) |
void magmablas_slascl_2x2_q | ( | magma_type_t | type, |
magma_int_t | m, | ||
magmaFloat_const_ptr | dW, | ||
magma_int_t | lddw, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue, | ||
magma_int_t * | info | ||
) |
SLASCL_2x2 scales the M by M real matrix A by the 2-by-2 pivot.
TYPE specifies that A may be upper or lower triangular.
[in] | type | magma_type_t TYPE indices the storage type of the input matrix A. = MagmaLower: lower triangular matrix. = MagmaUpper: upper triangular matrix. Other formats that LAPACK supports, MAGMA does not currently support. |
[in] | m | INTEGER The number of rows of the matrix A. M >= 0. |
[in] | dW | REAL vector, dimension (2*lddw) The matrix containing the 2-by-2 pivot. |
[in] | lddw | INTEGER The leading dimension of the array W. LDDA >= max(1,M). |
[in,out] | dA | REAL array, dimension (LDDA,N) The matrix to be scaled by dW. See TYPE for the storage type. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slascl_diag | ( | magma_type_t | type, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dD, | ||
magma_int_t | lddd, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | info | ||
) |
void magmablas_slascl_diag_q | ( | magma_type_t | type, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_const_ptr | dD, | ||
magma_int_t | lddd, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue, | ||
magma_int_t * | info | ||
) |
SLASCL_DIAG scales the M by N real matrix A by the real diagonal matrix dD.
TYPE specifies that A may be upper triangular or lower triangular.
[in] | type | magma_type_t TYPE indices the storage type of the input matrix A. = MagmaLower: lower triangular matrix. = MagmaUpper: upper triangular matrix. Other formats that LAPACK supports, MAGMA does not currently support. |
[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] | dD | REAL vector, dimension (LDDD,M) The matrix storing the scaling factor on its diagonal. |
[in] | lddd | INTEGER The leading dimension of the array D. |
[in,out] | dA | REAL array, dimension (LDDA,N) The matrix to be scaled by dD. See TYPE for the storage type. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slascl_q | ( | magma_type_t | type, |
magma_int_t | kl, | ||
magma_int_t | ku, | ||
float | cfrom, | ||
float | cto, | ||
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue, | ||
magma_int_t * | info | ||
) |
SLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM.
This is done without over/underflow as long as the final result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that A may be full, upper triangular, lower triangular.
[in] | type | magma_type_t TYPE indices the storage type of the input matrix A. = MagmaFull: full matrix. = MagmaLower: lower triangular matrix. = MagmaUpper: upper triangular matrix. Other formats that LAPACK supports, MAGMA does not currently support. |
[in] | kl | INTEGER Unused, for LAPACK compatability. |
[in] | ku | KU is INTEGER Unused, for LAPACK compatability. |
[in] | cfrom | REAL |
[in] | cto | REAL The matrix A is multiplied by CTO/CFROM. A(I,J) is computed without over/underflow if the final result CTO*A(I,J)/CFROM can be represented without over/underflow. CFROM must be nonzero. CFROM and CTO must not be NAN. |
[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, dimension (LDDA,N) The matrix to be multiplied by CTO/CFROM. See TYPE for the storage type. |
[in] | ldda | INTEGER The leading dimension of the array A. LDDA >= max(1,M). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slaset | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
float | offdiag, | ||
float | diag, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_slaset_band | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t | k, | ||
float | offdiag, | ||
float | diag, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_slaset_band_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t | k, | ||
float | offdiag, | ||
float | diag, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue | ||
) |
SLASET_BAND initializes the main diagonal of dA to DIAG, and the K-1 sub- or super-diagonals to OFFDIAG.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA to be set.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | k | INTEGER The number of diagonals to set, including the main diagonal. K >= 0. Currently, K <= 1024 due to CUDA restrictions (max. number of threads per block). |
[in] | offdiag | REAL Off-diagonal elements in the band are set to OFFDIAG. |
[in] | diag | REAL All the main diagonal elements are set to DIAG. |
[in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. On exit, A(i,j) = ALPHA, 1 <= i <= m, 1 <= j <= n where i != j, abs(i-j) < k; and A(i,i) = BETA, 1 <= i <= min(m,n) |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | queue | magma_queue_t Stream to execute SLASET in. |
void magmablas_slaset_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
float | offdiag, | ||
float | diag, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue | ||
) |
SLASET initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA to be set.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | offdiag | REAL The scalar OFFDIAG. (In LAPACK this is called ALPHA.) |
[in] | diag | REAL The scalar DIAG. (In LAPACK this is called BETA.) |
[in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. If UPLO = MagmaUpper, only the upper triangle or trapezoid is accessed; if UPLO = MagmaLower, only the lower triangle or trapezoid is accessed. On exit, A(i,j) = OFFDIAG, 1 <= i <= m, 1 <= j <= n, i != j; and A(i,i) = DIAG, 1 <= i <= min(m,n) |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slaswp | ( | magma_int_t | n, |
magmaFloat_ptr | dAT, | ||
magma_int_t | ldda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci | ||
) |
void magmablas_slaswp2 | ( | magma_int_t | n, |
magmaFloat_ptr | dAT, | ||
magma_int_t | ldda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
magmaInt_const_ptr | d_ipiv, | ||
magma_int_t | inci | ||
) |
void magmablas_slaswp2_q | ( | magma_int_t | n, |
magmaFloat_ptr | dAT, | ||
magma_int_t | ldda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
magmaInt_const_ptr | d_ipiv, | ||
magma_int_t | inci, | ||
magma_queue_t | queue | ||
) |
One row interchange is initiated for each of rows K1 through K2 of A.
Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.
Here, d_ipiv is passed in GPU memory.
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dAT | REAL array on GPU, stored row-wise, dimension (LDDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | ldda | INTEGER The leading dimension of the array A. (I.e., stride between elements in a column.) |
[in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.) |
[in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.) |
[in] | d_ipiv | INTEGER array, on GPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged. |
[in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slaswp_q | ( | magma_int_t | n, |
magmaFloat_ptr | dAT, | ||
magma_int_t | ldda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci, | ||
magma_queue_t | queue | ||
) |
One row interchange is initiated for each of rows K1 through K2 of A.
Unlike LAPACK, here A is stored row-wise (hence dAT). ** Otherwise, this is identical to LAPACK's interface.
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dAT | REAL array on GPU, stored row-wise, dimension (LDDA,M) The M-by-N matrix, stored transposed as N-by-M matrix embedded in LDDA-by-M array. M is not given; it is implicit. On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | ldda | INTEGER The leading dimension of the array A. ldda >= n. |
[in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1.) |
[in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2.) |
[in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged. |
[in] | inci | INTEGER The increment between successive values of IPIV. Currently, INCI > 0. TODO: If INCI is negative, the pivots are applied in reverse order. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slaswp_sym | ( | magma_int_t | n, |
float * | dA, | ||
magma_int_t | lda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci | ||
) |
void magmablas_slaswp_sym_q | ( | magma_int_t | n, |
float * | dA, | ||
magma_int_t | lda, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci, | ||
magma_queue_t | queue | ||
) |
One row interchange is initiated for each of rows K1 through K2 of A.
Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dA | REAL array on GPU, dimension (*,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | lda | INTEGER Stride between elements in same column. |
[in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.) |
[in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.) |
[in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged. |
[in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_slaswpx | ( | magma_int_t | n, |
magmaFloat_ptr | dA, | ||
magma_int_t | ldx, | ||
magma_int_t | ldy, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci | ||
) |
void magmablas_slaswpx_q | ( | magma_int_t | n, |
magmaFloat_ptr | dA, | ||
magma_int_t | ldx, | ||
magma_int_t | ldy, | ||
magma_int_t | k1, | ||
magma_int_t | k2, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | inci, | ||
magma_queue_t | queue | ||
) |
One row interchange is initiated for each of rows K1 through K2 of A.
Unlike LAPACK, here A is stored either row-wise or column-wise, depending on ldx and ldy. ** Otherwise, this is identical to LAPACK's interface.
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dA | REAL array on GPU, dimension (*,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | ldx | INTEGER Stride between elements in same column. |
[in] | ldy | INTEGER Stride between elements in same row. For A stored row-wise, set ldx=ldda and ldy=1. For A stored column-wise, set ldx=1 and ldy=ldda. |
[in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (One based index.) |
[in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (One based index.) |
[in] | ipiv | INTEGER array, on CPU, dimension (K2*abs(INCI)) The vector of pivot indices. Only the elements in positions K1 through K2 of IPIV are accessed. IPIV(K) = L implies rows K and L are to be interchanged. |
[in] | inci | INTEGER The increment between successive values of IPIV. Currently, IPIV > 0. TODO: If IPIV is negative, the pivots are applied in reverse order. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_sswapdblk | ( | magma_int_t | n, |
magma_int_t | nb, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | inca, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_int_t | incb | ||
) |
void magmablas_sswapdblk_batched | ( | magma_int_t | n, |
magma_int_t | nb, | ||
float ** | dA_array, | ||
magma_int_t | ldda, | ||
magma_int_t | inca, | ||
float ** | dB_array, | ||
magma_int_t | lddb, | ||
magma_int_t | incb, | ||
magma_int_t | batchCount | ||
) |
void magmablas_sswapdblk_batched_q | ( | magma_int_t | n, |
magma_int_t | nb, | ||
float ** | dA_array, | ||
magma_int_t | ldda, | ||
magma_int_t | inca, | ||
float ** | dB_array, | ||
magma_int_t | lddb, | ||
magma_int_t | incb, | ||
magma_int_t | batchCount, | ||
magma_queue_t | queue | ||
) |
sswapdblk swaps diagonal blocks of size nb x nb between matrices dA and dB on the GPU.
It swaps nblocks = ceil(n/nb) blocks. For i = 1 .. nblocks, submatrices dA( i*nb*inca, i*nb ) and dB( i*nb*incb, i*nb ) are swapped.
[in] | n | INTEGER The number of columns of the matrices dA and dB. N >= 0. |
[in] | nb | INTEGER The size of diagonal blocks. NB > 0 and NB <= maximum threads per CUDA block (512 or 1024). |
[in,out] | dA_array | Array of pointers, dimension (batchCount). Each is a REAL array dA, dimension (ldda,n) The matrix dA. |
[in] | ldda | INTEGER The leading dimension of each array dA. ldda >= (nblocks - 1)*nb*inca + nb. |
[in] | inca | INTEGER The row increment between diagonal blocks of dA. inca >= 0. For example, inca = 1 means blocks are stored on the diagonal at dA(i*nb, i*nb), inca = 0 means blocks are stored side-by-side at dA(0, i*nb). |
[in,out] | dB_array | Array of pointers, dimension (batchCount). Each is a REAL array dB, dimension (lddb,n) The matrix dB. |
[in] | lddb | INTEGER The leading dimension of each array dB. lddb >= (nblocks - 1)*nb*incb + nb. |
[in] | incb | INTEGER The row increment between diagonal blocks of dB. incb >= 0. See inca. |
[in] | batchCount | INTEGER The number of matrices to operate on. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_sswapdblk_q | ( | magma_int_t | n, |
magma_int_t | nb, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | inca, | ||
magmaFloat_ptr | dB, | ||
magma_int_t | lddb, | ||
magma_int_t | incb, | ||
magma_queue_t | queue | ||
) |
sswapdblk swaps diagonal blocks of size nb x nb between matrices dA and dB on the GPU.
It swaps nblocks = n/nb blocks. For i = 1 .. nblocks, submatrices dA( i*nb*inca, i*nb ) and dB( i*nb*incb, i*nb ) are swapped.
[in] | n | INTEGER The number of columns of the matrices dA and dB. N >= 0. |
[in] | nb | INTEGER The size of diagonal blocks. NB > 0 and NB <= maximum threads per CUDA block (512 or 1024). |
[in,out] | dA | REAL array, dimension (LDDA,N) The matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= (nblocks - 1)*nb*inca + nb. |
[in] | inca | INTEGER The row increment between diagonal blocks of dA. inca >= 0. For example, inca = 1 means blocks are stored on the diagonal at dA(i*nb, i*nb), inca = 0 means blocks are stored side-by-side at dA(0, i*nb). |
[in,out] | dB | REAL array, dimension (LDDB,N) The matrix dB. |
[in] | lddb | INTEGER The leading dimension of the array db. LDDB >= (nblocks - 1)*nb*incb + nb. |
[in] | incb | INTEGER The row increment between diagonal blocks of dB. incb >= 0. See inca. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_ssymmetrize | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_ssymmetrize_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue | ||
) |
SSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA that is valid on input.
|
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in,out] | dA | REAL array, dimension (LDDA,N) The m by m matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_ssymmetrize_tiles | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | ntile, | ||
magma_int_t | mstride, | ||
magma_int_t | nstride | ||
) |
void magmablas_ssymmetrize_tiles_q | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | ntile, | ||
magma_int_t | mstride, | ||
magma_int_t | nstride, | ||
magma_queue_t | queue | ||
) |
SSYMMETRIZE_TILES copies lower triangle to upper triangle, or vice-versa, to make some blocks of dA into general representations of a symmetric block.
This processes NTILE blocks, typically the diagonal blocks. Each block is offset by mstride rows and nstride columns from the previous block.
[in] | uplo | magma_uplo_t Specifies the part of the matrix dA that is valid on input.
|
[in] | m | INTEGER The number of rows & columns of each square block of dA. M >= 0. |
[in,out] | dA | REAL array, dimension (LDDA,N) The matrix dA. N = m + nstride*(ntile-1). |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1, m + mstride*(ntile-1)). |
[in] | ntile | INTEGER Number of blocks to symmetrize. ntile >= 0. |
[in] | mstride | INTEGER Row offset from start of one block to start of next block. mstride >= 0. Either (mstride >= m) or (nstride >= m), to prevent m-by-m tiles from overlapping. |
[in] | nstride | INTEGER Column offset from start of one block to start of next block. nstride >= 0. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_stranspose | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dAT, | ||
magma_int_t | lddat | ||
) |
void magmablas_stranspose_batched | ( | magma_int_t | m, |
magma_int_t | n, | ||
float ** | dA_array, | ||
magma_int_t | ldda, | ||
float ** | dAT_array, | ||
magma_int_t | lddat, | ||
magma_int_t | batchCount | ||
) |
void magmablas_stranspose_batched_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
float ** | dA_array, | ||
magma_int_t | ldda, | ||
float ** | dAT_array, | ||
magma_int_t | lddat, | ||
magma_int_t | batchCount, | ||
magma_queue_t | queue | ||
) |
stranspose_batched_q copies and transposes a matrix dA_array[i] to matrix dAT_array[i].
Same as stranspose_batched, but adds queue argument.
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | dA_array | REAL* array, dimension (batchCount) array of pointers to the matrices dA, where each dA is of dimension (LDDA,N) The M-by-N matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M. |
[in] | dAT_array | REAL* array, dimension (batchCount) array of pointers to the matrices dAT, where each dAT is of dimension (LDDAT,M) The N-by-M matrix dAT. |
[in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N. |
[in] | queue | magma_queue_t Queue to execute in. |
[in] | batchCount | Number of matrices in dA_array and dAT_array |
void magmablas_stranspose_inplace | ( | magma_int_t | n, |
magmaFloat_ptr | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_stranspose_inplace_q | ( | magma_int_t | n, |
magmaFloat_ptr | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | queue | ||
) |
stranspose_inplace_q transposes a square N-by-N matrix in-place.
Same as stranspose_inplace, but adds queue argument.
[in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0. |
[in] | dA | REAL array, dimension (LDDA,N) The N-by-N matrix dA. On exit, dA(j,i) = dA_original(i,j), for 0 <= i,j < N. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= N. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_stranspose_q | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloat_const_ptr | dA, | ||
magma_int_t | ldda, | ||
magmaFloat_ptr | dAT, | ||
magma_int_t | lddat, | ||
magma_queue_t | queue | ||
) |
stranspose_q copies and transposes a matrix dA to matrix dAT.
Same as stranspose, but adds queue argument.
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in] | dA | REAL array, dimension (LDDA,N) The M-by-N matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M. |
[in] | dAT | REAL array, dimension (LDDAT,M) The N-by-M matrix dAT. |
[in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N. |
[in] | queue | magma_queue_t Queue to execute in. |