![]() |
MAGMA
1.5.0
Matrix Algebra for GPU and Multicore Architectures
|
Functions | |
void | magmablas_zclaswp (magma_int_t n, magmaDoubleComplex *a, magma_int_t lda, magmaFloatComplex *sa, magma_int_t m, const magma_int_t *ipiv, magma_int_t incx) |
Row i of A is cast to single precision in row ipiv[i] of SA, for 0 <= i < M. More... | |
void | magmablas_zgeadd (magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, const magmaDoubleComplex *dA, magma_int_t ldda, magmaDoubleComplex *dB, magma_int_t lddb) |
ZGEADD adds two matrices, dB = alpha*dA + dB. More... | |
void | magmablas_zgeadd_batched (magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, const magmaDoubleComplex *const *dAarray, magma_int_t ldda, magmaDoubleComplex **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_zlacpy (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaDoubleComplex *dA, magma_int_t ldda, magmaDoubleComplex *dB, magma_int_t lddb) |
NoteMore... | |
void | magmablas_zlacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const magmaDoubleComplex *const *dAarray, magma_int_t ldda, magmaDoubleComplex **dBarray, magma_int_t lddb, magma_int_t batchCount) |
NoteMore... | |
void | magmablas_zlag2c (magma_int_t m, magma_int_t n, const magmaDoubleComplex *A, magma_int_t lda, magmaFloatComplex *SA, magma_int_t ldsa, magma_int_t *info) |
ZLAG2C converts a double-complex matrix, A, to a single-complex matrix, SA. More... | |
double | magmablas_zlange (magma_norm_t norm, magma_int_t m, magma_int_t n, const magmaDoubleComplex *A, magma_int_t lda, double *dwork) |
ZLANGE 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... | |
double | magmablas_zlanhe (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, const magmaDoubleComplex *A, magma_int_t lda, double *dwork) |
ZLANHE 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_zswapdblk (magma_int_t n, magma_int_t nb, magmaDoubleComplex *dA1, magma_int_t ldda1, magma_int_t inca1, magmaDoubleComplex *dA2, magma_int_t ldda2, magma_int_t inca2) |
This is an auxiliary MAGMA routine. More... | |
void | magmablas_zsymmetrize (magma_uplo_t uplo, magma_int_t m, magmaDoubleComplex *dA, magma_int_t ldda) |
ZSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix. More... | |
void | magmablas_zsymmetrize_tiles (magma_uplo_t uplo, magma_int_t m, magmaDoubleComplex *dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride) |
ZSYMMETRIZE_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_zclaswp | ( | magma_int_t | n, |
magmaDoubleComplex * | a, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | sa, | ||
magma_int_t | m, | ||
const magma_int_t * | ipiv, | ||
magma_int_t | incx | ||
) |
Row i of A is cast to single precision in row ipiv[i] of SA, for 0 <= i < M.
N - (input) INTEGER. On entry, N specifies the number of columns of the matrix A.
A - (input) DOUBLE PRECISION array on the GPU, dimension (LDA,N) On entry, the M-by-N matrix to which the row interchanges will be applied.
LDA - (input) INTEGER. LDA specifies the leading dimension of A.
SA - (output) REAL array on the GPU, dimension (LDA,N) On exit, the single precision, permuted matrix.
M - (input) The number of rows to be interchanged.
IPIV - (input) 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.
INCX - (input) INTEGER If IPIV is negative, the pivots are applied in reverse order, otherwise in straight-forward order.
void magmablas_zgeadd | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaDoubleComplex | alpha, | ||
const magmaDoubleComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaDoubleComplex * | 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 DOUBLE PRECISION The scalar alpha. |
[in] | dA | COMPLEX 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 | COMPLEX 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). |
void magmablas_zgeadd_batched | ( | magma_int_t | m, |
magma_int_t | n, | ||
magmaDoubleComplex | alpha, | ||
const magmaDoubleComplex *const * | dAarray, | ||
magma_int_t | ldda, | ||
magmaDoubleComplex ** | 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 DOUBLE PRECISION The scalar alpha. |
[in] | dAarray | array on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX 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 COMPLEX 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. |
void magmablas_zlacpy | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaDoubleComplex * | dA, | ||
magma_int_t | ldda, | ||
magmaDoubleComplex * | dB, | ||
magma_int_t | lddb | ||
) |
ZLACPY 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 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 | COMPLEX 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). |
void magmablas_zlacpy_batched | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaDoubleComplex *const * | dAarray, | ||
magma_int_t | ldda, | ||
magmaDoubleComplex ** | dBarray, | ||
magma_int_t | lddb, | ||
magma_int_t | batchCount | ||
) |
ZLACPY 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 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 COMPLEX 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. |
void magmablas_zlag2c | ( | magma_int_t | m, |
magma_int_t | n, | ||
const magmaDoubleComplex * | A, | ||
magma_int_t | lda, | ||
magmaFloatComplex * | SA, | ||
magma_int_t | ldsa, | ||
magma_int_t * | info | ||
) |
ZLAG2C converts a double-complex matrix, A, to a single-complex matrix, SA.
RMAX is the overflow for the single-complex arithmetic. ZLAG2C checks that all the entries of A are between -RMAX and RMAX. If not, the conversion is aborted and a flag is raised.
[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 | COMPLEX_16 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 | COMPLEX 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
|
double magmablas_zlange | ( | magma_norm_t | norm, |
magma_int_t | m, | ||
magma_int_t | n, | ||
const magmaDoubleComplex * | A, | ||
magma_int_t | lda, | ||
double * | dwork | ||
) |
ZLANGE 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.
ZLANGE returns the value
ZLANGE = ( 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 ZLANGE as described above. |
[in] | m | INTEGER The number of rows of the matrix A. M >= 0. When M = 0, ZLANGE is set to zero. |
[in] | n | INTEGER The number of columns of the matrix A. N >= 0. When N = 0, ZLANGE 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_zlanhe | ( | magma_norm_t | norm, |
magma_uplo_t | uplo, | ||
magma_int_t | n, | ||
const magmaDoubleComplex * | A, | ||
magma_int_t | lda, | ||
double * | dwork | ||
) |
ZLANHE 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.
ZLANHE = ( 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 ZLANHE < 0: if ZLANHE = -i, the i-th argument had an illegal value.
[in] | norm | CHARACTER*1 Specifies the value to be returned in ZLANHE 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, ZLANHE is set to zero. |
[in] | A | COMPLEX*16 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) 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_zswapdblk | ( | magma_int_t | n, |
magma_int_t | nb, | ||
magmaDoubleComplex * | dA1, | ||
magma_int_t | ldda1, | ||
magma_int_t | inca1, | ||
magmaDoubleComplex * | 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_zsymmetrize | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaDoubleComplex * | dA, | ||
magma_int_t | ldda | ||
) |
ZSYMMETRIZE 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 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). |
void magmablas_zsymmetrize_tiles | ( | magma_uplo_t | uplo, |
magma_int_t | m, | ||
magmaDoubleComplex * | dA, | ||
magma_int_t | ldda, | ||
magma_int_t | ntile, | ||
magma_int_t | mstride, | ||
magma_int_t | nstride | ||
) |
ZSYMMETRIZE_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 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. |
[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. |