Functions | |
void | magma_dprint (magma_int_t m, magma_int_t n, const double *A, magma_int_t lda) |
magma_dprint prints a matrix that is located on the CPU host. | |
void | magma_dprint_gpu (magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda) |
magma_dprint_gpu prints a matrix that is located on the GPU device. | |
magma_int_t | magma_dnan_inf (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *A, magma_int_t lda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_dnan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values. | |
magma_int_t | magma_dnan_inf_gpu (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_dnan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values. | |
void | magmablas_dgeadd_q (magma_int_t m, magma_int_t n, double alpha, const double *dA, magma_int_t ldda, double *dB, magma_int_t lddb, magma_queue_t queue) |
ZGEADD adds two matrices, dB = alpha*dA + dB. | |
void | magmablas_dgeadd (magma_int_t m, magma_int_t n, double alpha, const double *dA, magma_int_t ldda, double *dB, magma_int_t lddb) |
void | magmablas_dgeadd_batched_q (magma_int_t m, magma_int_t n, double alpha, const double *const *dAarray, magma_int_t ldda, double **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, . | |
void | magmablas_dgeadd_batched (magma_int_t m, magma_int_t n, double alpha, const double *const *dAarray, magma_int_t ldda, double **dBarray, magma_int_t lddb, magma_int_t batchCount) |
void | magmablas_dlacpy_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda, double *dB, magma_int_t lddb, magma_queue_t queue) |
DLACPY_STREAM copies all or part of a two-dimensional matrix dA to another matrix dB. | |
void | magmablas_dlacpy (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda, double *dB, magma_int_t lddb) |
void | magmablas_dlacpy_batched_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *const *dAarray, magma_int_t ldda, double **dBarray, magma_int_t lddb, magma_int_t batchCount, magma_queue_t queue) |
Note --------
| |
void | magmablas_dlacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const double *const *dAarray, magma_int_t ldda, double **dBarray, magma_int_t lddb, magma_int_t batchCount) |
void | magmablas_dlag2s_q (magma_int_t m, magma_int_t n, const double *A, magma_int_t lda, float *SA, magma_int_t ldsa, magma_int_t *info, magma_queue_t queue) |
DLAG2S_STREAM converts a double-real matrix, A, to a single-real matrix, SA. | |
void | magmablas_dlag2s (magma_int_t m, magma_int_t n, const double *A, magma_int_t lda, float *SA, magma_int_t ldsa, magma_int_t *info) |
double | magmablas_dlange (magma_norm_t norm, magma_int_t m, magma_int_t n, const double *A, magma_int_t lda, double *dwork) |
DLANGE 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. | |
double | magmablas_dlansy (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, const double *A, magma_int_t lda, double *dwork) |
DLANSY 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. | |
void | magmablas_dlascl_q (magma_type_t type, magma_int_t kl, magma_int_t ku, double cfrom, double cto, magma_int_t m, magma_int_t n, double *dA, magma_int_t ldda, magma_int_t *info, magma_queue_t queue) |
DLASCL multiplies the M by N real matrix A by the real scalar CTO/CFROM. | |
void | magmablas_dlascl (magma_type_t type, magma_int_t kl, magma_int_t ku, double cfrom, double cto, magma_int_t m, magma_int_t n, double *dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_dlascl2_q (magma_type_t type, magma_int_t m, magma_int_t n, const double *dD, double *dA, magma_int_t ldda, magma_int_t *info, magma_queue_t queue) |
DLASCL2 scales the M by N real matrix A by the real diagonal matrix dD. | |
void | magmablas_dlascl2 (magma_type_t type, magma_int_t m, magma_int_t n, const double *dD, double *dA, magma_int_t ldda, magma_int_t *info) |
void | magmablas_dlaset_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, double offdiag, double diag, double *dA, magma_int_t ldda, magma_queue_t queue) |
DLASET_STREAM initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals. | |
void | magmablas_dlaset (magma_uplo_t uplo, magma_int_t m, magma_int_t n, double offdiag, double diag, double *dA, magma_int_t ldda) |
void | magmablas_dlaset_band_q (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, double offdiag, double diag, double *dA, magma_int_t ldda, magma_queue_t queue) |
DLASET_BAND_STREAM initializes the main diagonal of dA to DIAG, and the K-1 sub- or super-diagonals to OFFDIAG. | |
void | magmablas_dlaset_band (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, double offdiag, double diag, double *dA, magma_int_t ldda) |
void | magmablas_dlaswp_q (magma_int_t n, double *dAT, 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: ============= DLASWP performs a series of row interchanges on the matrix A. | |
void | magmablas_dlaswp (magma_int_t n, double *dAT, magma_int_t lda, magma_int_t k1, magma_int_t k2, const magma_int_t *ipiv, magma_int_t inci) |
void | magmablas_dlaswpx_q (magma_int_t n, double *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: ============= DLASWPX performs a series of row interchanges on the matrix A. | |
void | magmablas_dlaswpx (magma_int_t n, double *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_dlaswp2_q (magma_int_t n, double *dAT, magma_int_t lda, magma_int_t k1, magma_int_t k2, const magma_int_t *d_ipiv, magma_int_t inci, magma_queue_t queue) |
Purpose: ============= DLASWP2 performs a series of row interchanges on the matrix A. | |
void | magmablas_dlaswp2 (magma_int_t n, double *dAT, magma_int_t lda, magma_int_t k1, magma_int_t k2, const magma_int_t *d_ipiv, magma_int_t inci) |
void | magmablas_dlat2s_q (magma_uplo_t uplo, magma_int_t n, const double *A, magma_int_t lda, float *SA, magma_int_t ldsa, magma_int_t *info, magma_queue_t queue) |
DLAT2S converts a double-real matrix, A, to a single-real matrix, SA. | |
void | magmablas_dlat2s (magma_uplo_t uplo, magma_int_t n, const double *A, magma_int_t lda, float *SA, magma_int_t ldsa, magma_int_t *info) |
void | magmablas_dslaswp_q (magma_int_t n, double *A, magma_int_t lda, float *SA, magma_int_t m, const magma_int_t *ipiv, magma_int_t incx, magma_queue_t queue) |
Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M. | |
void | magmablas_dslaswp (magma_int_t n, double *A, magma_int_t lda, float *SA, magma_int_t m, const magma_int_t *ipiv, magma_int_t incx) |
void | magmablas_dswapdblk_q (magma_int_t n, magma_int_t nb, double *dA, magma_int_t ldda, magma_int_t inca, double *dB, magma_int_t lddb, magma_int_t incb, magma_queue_t queue) |
dswapdblk swaps diagonal blocks of size nb x nb between matrices dA and dB on the GPU. | |
void | magmablas_dswapdblk (magma_int_t n, magma_int_t nb, double *dA, magma_int_t ldda, magma_int_t inca, double *dB, magma_int_t lddb, magma_int_t incb) |
void | magmablas_dsymmetrize_q (magma_uplo_t uplo, magma_int_t m, double *dA, magma_int_t ldda, magma_queue_t queue) |
DSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix. | |
void | magmablas_dsymmetrize (magma_uplo_t uplo, magma_int_t m, double *dA, magma_int_t ldda) |
void | magmablas_dsymmetrize_tiles_q (magma_uplo_t uplo, magma_int_t m, double *dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride, magma_queue_t queue) |
DSYMMETRIZE_TILES copies lower triangle to upper triangle, or vice-versa, to make some blocks of dA into general representations of a symmetric block. | |
void | magmablas_dsymmetrize_tiles (magma_uplo_t uplo, magma_int_t m, double *dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride) |
void | magmablas_dtranspose_q (magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda, double *dAT, magma_int_t lddat, magma_queue_t queue) |
dtranspose_q copies and transposes a matrix dA to matrix dAT. | |
void | magmablas_dtranspose (magma_int_t m, magma_int_t n, const double *dA, magma_int_t ldda, double *dAT, magma_int_t lddat) |
void | magmablas_dtranspose_inplace_q (magma_int_t n, double *dA, magma_int_t ldda, magma_queue_t queue) |
dtranspose_inplace_q transposes a square N-by-N matrix in-place. | |
void | magmablas_dtranspose_inplace (magma_int_t n, double *dA, magma_int_t ldda) |
void | magmablas_slat2d_q (magma_uplo_t uplo, magma_int_t n, const float *SA, magma_int_t ldsa, double *A, magma_int_t lda, magma_int_t *info, magma_queue_t queue) |
SLAT2D_STREAM converts a single-real matrix, SA, to a double-real matrix, A. | |
void | magmablas_slat2d (magma_uplo_t uplo, magma_int_t n, const float *SA, magma_int_t ldsa, double *A, magma_int_t lda, magma_int_t *info) |
magma_int_t magma_dnan_inf | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | cnt_nan, | |||
magma_int_t * | cnt_inf | |||
) |
magma_dnan_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 | DOUBLE_PRECISION 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_dnan_inf_gpu | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | cnt_nan, | |||
magma_int_t * | cnt_inf | |||
) |
magma_dnan_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 | DOUBLE_PRECISION 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_dprint | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda | |||
) |
magma_dprint 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 | DOUBLE_PRECISION 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_dprint_gpu | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda | |||
) |
magma_dprint_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 | DOUBLE_PRECISION 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_dgeadd | ( | magma_int_t | m, | |
magma_int_t | n, | |||
double | alpha, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | dB, | |||
magma_int_t | lddb | |||
) |
void magmablas_dgeadd_batched | ( | magma_int_t | m, | |
magma_int_t | n, | |||
double | alpha, | |||
const double *const * | dAarray, | |||
magma_int_t | ldda, | |||
double ** | dBarray, | |||
magma_int_t | lddb, | |||
magma_int_t | batchCount | |||
) |
void magmablas_dgeadd_batched_q | ( | magma_int_t | m, | |
magma_int_t | n, | |||
double | alpha, | |||
const double *const * | dAarray, | |||
magma_int_t | ldda, | |||
double ** | 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 | DOUBLE_PRECISION The scalar alpha. |
[in] | dAarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a DOUBLE_PRECISION 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 DOUBLE_PRECISION 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_dgeadd_q | ( | magma_int_t | m, | |
magma_int_t | n, | |||
double | alpha, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | 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 | DOUBLE_PRECISION The scalar alpha. |
[in] | dA | DOUBLE_PRECISION 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 | DOUBLE_PRECISION 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_dlacpy | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | dB, | |||
magma_int_t | lddb | |||
) |
void magmablas_dlacpy_batched | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double *const * | dAarray, | |||
magma_int_t | ldda, | |||
double ** | dBarray, | |||
magma_int_t | lddb, | |||
magma_int_t | batchCount | |||
) |
void magmablas_dlacpy_batched_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double *const * | dAarray, | |||
magma_int_t | ldda, | |||
double ** | dBarray, | |||
magma_int_t | lddb, | |||
magma_int_t | batchCount, | |||
magma_queue_t | queue | |||
) |
Note --------
DLACPY copies all or part of a set of two-dimensional matrices dAarray[i] to another set of matrices dBarray[i], for i = 0, ..., batchCount-1.
[in] | uplo | magma_uplo_t Specifies the part of each matrix dAarray[i] to be copied to dBarray[i].
|
[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] | dAarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a DOUBLE_PRECISION array, dimension (LDDA,N) The m by n matrices dAarray[i]. 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 dAarray[i]. LDDA >= max(1,M). |
[out] | dBarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a DOUBLE_PRECISION array, dimension (LDDB,N) The m by n matrices dBarray[i]. On exit, matrix dBarray[i] = matrix dAarray[i] in the locations specified by UPLO. |
[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_dlacpy_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | dB, | |||
magma_int_t | lddb, | |||
magma_queue_t | queue | |||
) |
DLACPY_STREAM copies all or part of a two-dimensional matrix dA to another matrix dB.
This is the same as DLACPY, 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] | dA | DOUBLE_PRECISION 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 | DOUBLE_PRECISION 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_dlag2s | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | ldsa, | |||
magma_int_t * | info | |||
) |
void magmablas_dlag2s_q | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | ldsa, | |||
magma_int_t * | info, | |||
magma_queue_t | queue | |||
) |
DLAG2S_STREAM converts a double-real matrix, A, to a single-real matrix, SA.
RMAX is the overflow for the single-real arithmetic. DLAG2S checks that all the entries of A are between -RMAX and RMAX. If not, the conversion is aborted and a flag is raised.
This is the same as DLAG2S, but adds queue argument.
[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] | A | DOUBLE PRECISION array, dimension (LDA,n) On entry, the m-by-n coefficient matrix A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,m). |
[out] | SA | SINGLE PRECISION array, dimension (LDSA,n) On exit, if INFO=0, the m-by-n coefficient matrix SA; if INFO > 0, the content of SA is unspecified. |
[in] | ldsa | INTEGER The leading dimension of the array SA. LDSA >= max(1,m). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
double magmablas_dlange | ( | magma_norm_t | norm, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
double * | dwork | |||
) |
DLANGE 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.
Description ----------- DLANGE returns the value
DLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm' ** not yet supported ( ( norm1(A), NORM = '1', 'O' or 'o' ** not yet supported ( ( normI(A), NORM = 'I' or 'i' ( ( normF(A), NORM = 'F', 'f', 'E' or 'e' ** 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 | CHARACTER*1 Specifies the value to be returned in DLANGE as described above. |
[in] | m | INTEGER The number of rows of the matrix A. M >= 0. When M = 0, DLANGE is set to zero. |
[in] | n | INTEGER The number of columns of the matrix A. N >= 0. When N = 0, DLANGE is set to zero. |
[in] | A | DOUBLE PRECISION array on the GPU, dimension (LDA,N) The m by n matrix A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(M,1). |
dwork | (workspace) DOUBLE PRECISION array on the GPU, dimension (MAX(1,LWORK)), where LWORK >= M when NORM = 'I'; otherwise, WORK is not referenced. |
double magmablas_dlansy | ( | magma_norm_t | norm, | |
magma_uplo_t | uplo, | |||
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
double * | dwork | |||
) |
DLANSY 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.
DLANSY = ( max(abs(A(i,j))), NORM = 'M' or 'm' ( ( norm1(A), NORM = '1', 'O' or 'o' ** supported only for (PRECISION_s || PRECISION_d || PRECISION_c || __CUDA_ARCH__ >= 200) ( ( normI(A), NORM = 'I' or 'i' ** supported only for (PRECISION_s || PRECISION_d || PRECISION_c || __CUDA_ARCH__ >= 200) ( ( normF(A), NORM = 'F', 'f', 'E' or 'e' ** 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.
Returns DLANSY < 0: if DLANSY = -i, the i-th argument had an illegal value.
Arguments: ----------
[in] | norm | CHARACTER*1 Specifies the value to be returned in DLANSY 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, DLANSY is set to zero. |
[in] | A | DOUBLE PRECISION array on the GPU, dimension (LDA,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] | lda | INTEGER The leading dimension of the array A. LDA >= max(N,1). |
dwork | (workspace) DOUBLE PRECISION 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. |
void magmablas_dlascl | ( | magma_type_t | type, | |
magma_int_t | kl, | |||
magma_int_t | ku, | |||
double | cfrom, | |||
double | cto, | |||
magma_int_t | m, | |||
magma_int_t | n, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | info | |||
) |
void magmablas_dlascl2 | ( | magma_type_t | type, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | dD, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | info | |||
) |
void magmablas_dlascl2_q | ( | magma_type_t | type, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
const double * | dD, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | info, | |||
magma_queue_t | queue | |||
) |
DLASCL2 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 | DOUBLE PRECISION vector, dimension (M) The diagonal matrix containing the scalar factors. Stored as a vector. |
[in,out] | dA | DOUBLE PRECISION 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_dlascl_q | ( | magma_type_t | type, | |
magma_int_t | kl, | |||
magma_int_t | ku, | |||
double | cfrom, | |||
double | cto, | |||
magma_int_t | m, | |||
magma_int_t | n, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t * | info, | |||
magma_queue_t | queue | |||
) |
DLASCL 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 | DOUBLE PRECISION |
[in] | cto | DOUBLE PRECISION 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 | DOUBLE PRECISION 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_dlaset | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
double | offdiag, | |||
double | diag, | |||
double * | dA, | |||
magma_int_t | ldda | |||
) |
void magmablas_dlaset_band | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
magma_int_t | k, | |||
double | offdiag, | |||
double | diag, | |||
double * | dA, | |||
magma_int_t | ldda | |||
) |
void magmablas_dlaset_band_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
magma_int_t | k, | |||
double | offdiag, | |||
double | diag, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_queue_t | queue | |||
) |
DLASET_BAND_STREAM initializes the main diagonal of dA to DIAG, and the K-1 sub- or super-diagonals to OFFDIAG.
This is the same as DLASET_BAND, but adds queue argument.
[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 | DOUBLE_PRECISION Off-diagonal elements in the band are set to OFFDIAG. |
[in] | diag | DOUBLE_PRECISION All the main diagonal elements are set to DIAG. |
[in] | dA | DOUBLE_PRECISION 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; 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 DLASET in. |
void magmablas_dlaset_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
magma_int_t | n, | |||
double | offdiag, | |||
double | diag, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_queue_t | queue | |||
) |
DLASET_STREAM initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals.
This is the same as DLASET, but adds queue argument.
[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 | DOUBLE_PRECISION The scalar OFFDIAG. (In LAPACK this is called ALPHA.) |
[in] | diag | DOUBLE_PRECISION The scalar DIAG. (In LAPACK this is called BETA.) |
[in] | dA | DOUBLE_PRECISION 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; 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_dlaswp | ( | magma_int_t | n, | |
double * | dAT, | |||
magma_int_t | lda, | |||
magma_int_t | k1, | |||
magma_int_t | k2, | |||
const magma_int_t * | ipiv, | |||
magma_int_t | inci | |||
) |
void magmablas_dlaswp2 | ( | magma_int_t | n, | |
double * | dAT, | |||
magma_int_t | lda, | |||
magma_int_t | k1, | |||
magma_int_t | k2, | |||
const magma_int_t * | d_ipiv, | |||
magma_int_t | inci | |||
) |
void magmablas_dlaswp2_q | ( | magma_int_t | n, | |
double * | dAT, | |||
magma_int_t | lda, | |||
magma_int_t | k1, | |||
magma_int_t | k2, | |||
const magma_int_t * | d_ipiv, | |||
magma_int_t | inci, | |||
magma_queue_t | queue | |||
) |
Purpose: ============= DLASWP2 performs a series of row interchanges on the matrix A.
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.
Arguments: ==========
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dAT | DOUBLE PRECISION array on GPU, stored row-wise, dimension (LDA,*) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | lda | 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_dlaswp_q | ( | magma_int_t | n, | |
double * | dAT, | |||
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: ============= DLASWP performs a series of row interchanges on the matrix A.
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.
Arguments: ==========
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dAT | DOUBLE PRECISION array on GPU, stored row-wise, dimension (LDA,N) On entry, the matrix of column dimension N to which the row interchanges will be applied. On exit, the permuted matrix. |
[in] | lda | INTEGER The leading dimension of the array A. lda >= n. |
[in] | k1 | INTEGER The first element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k1 <= n.) |
[in] | k2 | INTEGER The last element of IPIV for which a row interchange will be done. (Fortran one-based index: 1 <= k2 <= n.) |
[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_dlaswpx | ( | magma_int_t | n, | |
double * | 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_dlaswpx_q | ( | magma_int_t | n, | |
double * | 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: ============= DLASWPX performs a series of row interchanges on the matrix A.
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.
Arguments: ==========
[in] | n | INTEGER The number of columns of the matrix A. |
[in,out] | dA | DOUBLE PRECISION 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=lda and ldy=1. For A stored column-wise, set ldx=1 and ldy=lda. |
[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_dlat2s | ( | magma_uplo_t | uplo, | |
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | ldsa, | |||
magma_int_t * | info | |||
) |
void magmablas_dlat2s_q | ( | magma_uplo_t | uplo, | |
magma_int_t | n, | |||
const double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | ldsa, | |||
magma_int_t * | info, | |||
magma_queue_t | queue | |||
) |
DLAT2S converts a double-real matrix, A, to a single-real matrix, SA.
RMAX is the overflow for the single-real arithmetic. DLAT2S checks that all the entries of A are between -RMAX and RMAX. If not, the conversion is aborted and a flag is raised.
[in] | uplo | magma_uplo_t Specifies the part of the matrix A to be converted.
|
[in] | n | INTEGER The number of columns of the matrix A. n >= 0. |
[in] | A | DOUBLE PRECISION array, dimension (LDA,n) On entry, the n-by-n coefficient matrix A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,n). |
[out] | SA | SINGLE PRECISION array, dimension (LDSA,n) On exit, if INFO=0, the n-by-n coefficient matrix SA; if INFO > 0, the content of SA is unspecified. |
[in] | ldsa | INTEGER The leading dimension of the array SA. LDSA >= max(1,n). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_dslaswp | ( | magma_int_t | n, | |
double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | m, | |||
const magma_int_t * | ipiv, | |||
magma_int_t | incx | |||
) |
void magmablas_dslaswp_q | ( | magma_int_t | n, | |
double * | A, | |||
magma_int_t | lda, | |||
float * | SA, | |||
magma_int_t | m, | |||
const magma_int_t * | ipiv, | |||
magma_int_t | incx, | |||
magma_queue_t | queue | |||
) |
Row i of A is cast to single precision in row ipiv[i] of SA (incx > 0), or row i of SA is cast to double precision in row ipiv[i] of A (incx < 0), for 0 <= i < M.
[in] | n | INTEGER. On entry, N specifies the number of columns of the matrix A. |
[in,out] | A | DOUBLE PRECISION array on the GPU, dimension (LDA,N) On entry, the M-by-N matrix to which the row interchanges will be applied. TODO update docs |
[in] | lda | INTEGER. LDA specifies the leading dimension of A. |
[in,out] | SA | REAL array on the GPU, dimension (LDA,N) On exit, the single precision, permuted matrix. TODO update docs |
[in] | m | The number of rows to be interchanged. |
[in] | ipiv | INTEGER array on the GPU, dimension (M) The vector of pivot indices. Row i of A is cast to single precision in row ipiv[i] of SA, for 0 <= i < m. |
[in] | incx | INTEGER If INCX is negative, the pivots are applied in reverse order, otherwise in straight-forward order. |
[in] | queue | magma_queue_t Queue to execute in. |
void magmablas_dswapdblk | ( | magma_int_t | n, | |
magma_int_t | nb, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t | inca, | |||
double * | dB, | |||
magma_int_t | lddb, | |||
magma_int_t | incb | |||
) |
void magmablas_dswapdblk_q | ( | magma_int_t | n, | |
magma_int_t | nb, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t | inca, | |||
double * | dB, | |||
magma_int_t | lddb, | |||
magma_int_t | incb, | |||
magma_queue_t | queue | |||
) |
dswapdblk 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 | DOUBLE_PRECISION 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 | DOUBLE_PRECISION 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_dsymmetrize | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
double * | dA, | |||
magma_int_t | ldda | |||
) |
void magmablas_dsymmetrize_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_queue_t | queue | |||
) |
DSYMMETRIZE 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 | DOUBLE_PRECISION 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_dsymmetrize_tiles | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t | ntile, | |||
magma_int_t | mstride, | |||
magma_int_t | nstride | |||
) |
void magmablas_dsymmetrize_tiles_q | ( | magma_uplo_t | uplo, | |
magma_int_t | m, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
magma_int_t | ntile, | |||
magma_int_t | mstride, | |||
magma_int_t | nstride, | |||
magma_queue_t | queue | |||
) |
DSYMMETRIZE_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 | DOUBLE_PRECISION 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_dtranspose | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | dAT, | |||
magma_int_t | lddat | |||
) |
void magmablas_dtranspose_inplace | ( | magma_int_t | n, | |
double * | dA, | |||
magma_int_t | ldda | |||
) |
void magmablas_dtranspose_inplace_q | ( | magma_int_t | n, | |
double * | dA, | |||
magma_int_t | ldda, | |||
magma_queue_t | queue | |||
) |
dtranspose_inplace_q transposes a square N-by-N matrix in-place.
Same as dtranspose_inplace, but adds queue argument.
[in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0. |
[in] | dA | DOUBLE_PRECISION 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_dtranspose_q | ( | magma_int_t | m, | |
magma_int_t | n, | |||
const double * | dA, | |||
magma_int_t | ldda, | |||
double * | dAT, | |||
magma_int_t | lddat, | |||
magma_queue_t | queue | |||
) |
dtranspose_q copies and transposes a matrix dA to matrix dAT.
Same as dtranspose, 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 | DOUBLE_PRECISION array, dimension (LDDA,N) The M-by-N matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M. |
[in] | dAT | DOUBLE_PRECISION array, dimension (LDDA,N) 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. |
void magmablas_slat2d | ( | magma_uplo_t | uplo, | |
magma_int_t | n, | |||
const float * | SA, | |||
magma_int_t | ldsa, | |||
double * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | info | |||
) |
void magmablas_slat2d_q | ( | magma_uplo_t | uplo, | |
magma_int_t | n, | |||
const float * | SA, | |||
magma_int_t | ldsa, | |||
double * | A, | |||
magma_int_t | lda, | |||
magma_int_t * | info, | |||
magma_queue_t | queue | |||
) |
SLAT2D_STREAM 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] | uplo | magma_uplo_t Specifies the part of the matrix A to be converted.
|
[in] | n | INTEGER The number of columns of the matrix A. n >= 0. |
[in] | A | DOUBLE PRECISION array, dimension (LDA,n) On entry, the n-by-n coefficient matrix A. |
[in] | lda | INTEGER The leading dimension of the array A. LDA >= max(1,n). |
[out] | SA | SINGLE PRECISION array, dimension (LDSA,n) On exit, if INFO=0, the n-by-n coefficient matrix SA; if INFO > 0, the content of SA is unspecified. |
[in] | ldsa | INTEGER The leading dimension of the array SA. LDSA >= max(1,n). |
[out] | info | INTEGER
|
[in] | queue | magma_queue_t Queue to execute in. |