![]() |
MAGMA
1.5.0
Matrix Algebra for GPU and Multicore Architectures
|
Functions | |
void | magma_cprint (magma_int_t m, magma_int_t n, const magmaFloatComplex *A, magma_int_t lda) |
magma_cprint prints a matrix that is located on the CPU host. More... | |
void | magma_cprint_gpu (magma_int_t m, magma_int_t n, const magmaFloatComplex *dA, magma_int_t ldda) |
magma_cprint_gpu prints a matrix that is located on the GPU device. More... | |
magma_int_t | magma_cnan_inf (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaFloatComplex *A, magma_int_t lda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_cnan_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_cnan_inf_gpu (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaFloatComplex *dA, magma_int_t ldda, magma_int_t *cnt_nan, magma_int_t *cnt_inf) |
magma_cnan_inf checks a matrix that is located on the CPU host for NAN (not-a-number) and INF (infinity) values. More... | |
void | magmablas_cgeadd (magma_int_t m, magma_int_t n, magmaFloatComplex alpha, const magmaFloatComplex *dA, magma_int_t ldda, magmaFloatComplex *dB, magma_int_t lddb) |
ZGEADD adds two matrices, dB = alpha*dA + dB. More... | |
void | magmablas_cgeadd_batched (magma_int_t m, magma_int_t n, magmaFloatComplex alpha, const magmaFloatComplex *const *dAarray, magma_int_t ldda, magmaFloatComplex **dBarray, magma_int_t lddb, magma_int_t batchCount) |
ZGEADD adds two sets of matrices, dAarray[i] = alpha*dAarray[i] + dBarray[i], for i = 0, ..., batchCount-1. More... | |
void | magmablas_clacpy (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaFloatComplex *dA, magma_int_t ldda, magmaFloatComplex *dB, magma_int_t lddb) |
NoteMore... | |
void | magmablas_clacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaFloatComplex *const *dAarray, magma_int_t ldda, magmaFloatComplex **dBarray, magma_int_t lddb, magma_int_t batchCount) |
NoteMore... | |
void | magmablas_clag2z (magma_int_t m, magma_int_t n, const magmaFloatComplex *SA, magma_int_t ldsa, magmaDoubleComplex *A, magma_int_t lda, magma_int_t *info) |
CLAG2Z converts a single-complex matrix, SA, to a double-complex matrix, A. More... | |
float | magmablas_clange (magma_norm_t norm, magma_int_t m, magma_int_t n, const magmaFloatComplex *A, magma_int_t lda, float *dwork) |
CLANGE 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_clanhe (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, const magmaFloatComplex *A, magma_int_t lda, float *dwork) |
CLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A. More... | |
void | magmablas_claset_stream (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex offdiag, magmaFloatComplex diag, magmaFloatComplex *dA, magma_int_t ldda, magma_queue_t stream) |
CLASET_STREAM initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals. More... | |
void | magmablas_claset (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magmaFloatComplex offdiag, magmaFloatComplex diag, magmaFloatComplex *dA, magma_int_t ldda) |
void | magmablas_claset_band_stream (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex offdiag, magmaFloatComplex diag, magmaFloatComplex *dA, magma_int_t ldda, magma_queue_t stream) |
CLASET_BAND_STREAM initializes the main diagonal of dA to DIAG, and the K-1 sub- or super-diagonals to OFFDIAG. More... | |
void | magmablas_claset_band (magma_uplo_t uplo, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex offdiag, magmaFloatComplex diag, magmaFloatComplex *dA, magma_int_t ldda) |
void | magmablas_cswapdblk (magma_int_t n, magma_int_t nb, magmaFloatComplex *dA1, magma_int_t ldda1, magma_int_t inca1, magmaFloatComplex *dA2, magma_int_t ldda2, magma_int_t inca2) |
This is an auxiliary MAGMA routine. More... | |
void | magmablas_csymmetrize (magma_uplo_t uplo, magma_int_t m, magmaFloatComplex *dA, magma_int_t ldda) |
CSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix. More... | |
void | magmablas_csymmetrize_tiles (magma_uplo_t uplo, magma_int_t m, magmaFloatComplex *dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride) |
CSYMMETRIZE_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_ctranspose_stream (magma_int_t m, magma_int_t n, const magmaFloatComplex *dA, magma_int_t ldda, magmaFloatComplex *dAT, magma_int_t lddat, magma_queue_t stream) |
ctranspose_stream copies and transposes a matrix dA to matrix dAT. More... | |
void | magmablas_ctranspose (magma_int_t m, magma_int_t n, const magmaFloatComplex *dA, magma_int_t ldda, magmaFloatComplex *dAT, magma_int_t lddat) |
void | magmablas_ctranspose_inplace_stream (magma_int_t n, magmaFloatComplex *dA, magma_int_t ldda, magma_queue_t stream) |
ctranspose_inplace_stream transposes a square N-by-N matrix in-place. More... | |
void | magmablas_ctranspose_inplace (magma_int_t n, magmaFloatComplex *dA, magma_int_t ldda) |
magma_int_t magma_cnan_inf | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
magma_int_t * | cnt_nan, | ||
magma_int_t * | cnt_inf | ||
) |
magma_cnan_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 | COMPLEX 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_cnan_inf_gpu | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_int_t * | cnt_nan, | ||
magma_int_t * | cnt_inf | ||
) |
magma_cnan_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,out] | dA | COMPLEX 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_cprint | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaFloatComplex * | A, | ||
magma_int_t | lda | ||
) |
magma_cprint 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 | COMPLEX 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_cprint_gpu | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda | ||
) |
magma_cprint_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 | COMPLEX 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_cgeadd | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloatComplex | alpha, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex * | dB, | ||
magma_int_t | lddb | ||
) |
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 | COMPLEX The scalar alpha. |
[in] | dA | COMPLEX 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 | COMPLEX array, dimension (LDDB,N) The m by n matrix dB. |
[in] | lddb | INTEGER The leading dimension of the array dB. LDDB >= max(1,M). |
void magmablas_cgeadd_batched | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaFloatComplex | alpha, | ||
const magmaFloatComplex *const * | dAarray, | ||
magma_int_t | ldda, | ||
magmaFloatComplex ** | dBarray, | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount | ||
) |
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 | COMPLEX The scalar alpha. |
[in] | dAarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX 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 COMPLEX 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. |
void magmablas_clacpy | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex * | dB, | ||
magma_int_t | lddb | ||
) |
CLACPY 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 | COMPLEX 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 | COMPLEX 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). |
void magmablas_clacpy_batched | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaFloatComplex *const * | dAarray, | ||
magma_int_t | ldda, | ||
magmaFloatComplex ** | dBarray, | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount | ||
) |
CLACPY 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 COMPLEX 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 COMPLEX 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. |
void magmablas_clag2z | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaFloatComplex * | SA, | ||
magma_int_t | ldsa, | ||
magmaDoubleComplex * | A, | ||
magma_int_t | lda, | ||
magma_int_t * | info | ||
) |
CLAG2Z converts a single-complex matrix, SA, to a double-complex 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 | REAL 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
|
float magmablas_clange | ( | magma_norm_t | norm, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
float * | dwork | ||
) |
CLANGE 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.
CLANGE returns the value
CLANGE = ( 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 CLANGE as described above. |
[in] | m | INTEGER The number of rows of the matrix A. M >= 0. When M = 0, CLANGE is set to zero. |
[in] | n | INTEGER The number of columns of the matrix A. N >= 0. When N = 0, CLANGE is set to zero. |
[in] | A | REAL 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) REAL array on the GPU, dimension (MAX(1,LWORK)), where LWORK >= M when NORM = 'I'; otherwise, WORK is not referenced. |
float magmablas_clanhe | ( | magma_norm_t | norm, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
const magmaFloatComplex * | A, | ||
magma_int_t | lda, | ||
float * | dwork | ||
) |
CLANHE returns the value of the one norm, or the Frobenius norm, or the infinity norm, or the element of largest absolute value of a complex Hermitian matrix A.
CLANHE = ( 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 CLANHE < 0: if CLANHE = -i, the i-th argument had an illegal value.
[in] | norm | CHARACTER*1 Specifies the value to be returned in CLANHE as described above. |
[in] | uplo | magma_uplo_t Specifies whether the upper or lower triangular part of the Hermitian matrix A is to be referenced.
|
[in] | n | INTEGER The order of the matrix A. N >= 0. When N = 0, CLANHE is set to zero. |
[in] | A | COMPLEX array on the GPU, dimension (LDA,N) The Hermitian 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) 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. |
void magmablas_claset | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloatComplex | offdiag, | ||
magmaFloatComplex | diag, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_claset_band | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t | k, | ||
magmaFloatComplex | offdiag, | ||
magmaFloatComplex | diag, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_claset_band_stream | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magma_int_t | k, | ||
magmaFloatComplex | offdiag, | ||
magmaFloatComplex | diag, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | stream | ||
) |
CLASET_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 CLASET_BAND, but adds stream 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 | COMPLEX Off-diagonal elements in the band are set to OFFDIAG. |
[in] | diag | COMPLEX All the main diagonal elements are set to DIAG. |
[in] | dA | COMPLEX 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] | stream | magma_queue_t Stream to execute CLASET in. |
void magmablas_claset_stream | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
magmaFloatComplex | offdiag, | ||
magmaFloatComplex | diag, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | stream | ||
) |
CLASET_STREAM initializes a 2-D array A to DIAG on the diagonal and OFFDIAG on the off-diagonals.
This is the same as CLASET, but adds stream 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 | COMPLEX The scalar OFFDIAG. (In LAPACK this is called ALPHA.) |
[in] | diag | COMPLEX The scalar DIAG. (In LAPACK this is called BETA.) |
[in] | dA | COMPLEX 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] | stream | magma_queue_t Stream to execute in. |
void magmablas_cswapdblk | ( | magma_int_t | n, |
magma_int_t | nb, | ||
magmaFloatComplex * | dA1, | ||
magma_int_t | ldda1, | ||
magma_int_t | inca1, | ||
magmaFloatComplex * | dA2, | ||
magma_int_t | ldda2, | ||
magma_int_t | inca2 | ||
) |
This is an auxiliary MAGMA routine.
It swaps diagonal blocks of size nb x nb between matrices dA1 and dA2 on the GPU.
The number of blocks swapped is (n-1)/nb. For i = 1 .. (n-1)/nb matrices dA1 + i * nb * (ldda1 + inca1) and dA2 + i * nb * (ldda2 + inca2) are swapped.
void magmablas_csymmetrize | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda | ||
) |
CSYMMETRIZE 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 | COMPLEX array, dimension (LDDA,N) The m by m matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
void magmablas_csymmetrize_tiles | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | ntile, | ||
magma_int_t | mstride, | ||
magma_int_t | nstride | ||
) |
CSYMMETRIZE_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 | COMPLEX 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. |
[in] | mstride | INTEGER Row offset from start of one block to start of next block. |
[in] | nstride | INTEGER Column offset from start of one block to start of next block. |
void magmablas_ctranspose | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex * | dAT, | ||
magma_int_t | lddat | ||
) |
void magmablas_ctranspose_inplace | ( | magma_int_t | n, |
magmaFloatComplex * | dA, | ||
magma_int_t | ldda | ||
) |
void magmablas_ctranspose_inplace_stream | ( | magma_int_t | n, |
magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_queue_t | stream | ||
) |
ctranspose_inplace_stream transposes a square N-by-N matrix in-place.
Same as ctranspose_inplace, but adds stream argument.
[in] | n | INTEGER The number of rows & columns of the matrix dA. N >= 0. |
[in] | dA | COMPLEX 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] | stream | magma_queue_t Stream to execute in. |
void magmablas_ctranspose_stream | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaFloatComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaFloatComplex * | dAT, | ||
magma_int_t | lddat, | ||
magma_queue_t | stream | ||
) |
ctranspose_stream copies and transposes a matrix dA to matrix dAT.
Same as ctranspose, but adds stream 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 | COMPLEX array, dimension (LDDA,N) The M-by-N matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= M. |
[in] | dAT | COMPLEX array, dimension (LDDA,N) The N-by-M matrix dAT. |
[in] | lddat | INTEGER The leading dimension of the array dAT. LDDAT >= N. |
[in] | stream | magma_queue_t Stream to execute in. |