MAGMA  1.5.0
Matrix Algebra for GPU and Multicore Architectures
 All Files Functions Groups
single precision

Functions

void magmablas_sgeadd (magma_int_t m, magma_int_t n, float alpha, const float *dA, magma_int_t ldda, float *dB, magma_int_t lddb)
 ZGEADD adds two matrices, dB = alpha*dA + dB. More...
 
void magmablas_sgeadd_batched (magma_int_t m, magma_int_t n, float alpha, const float *const *dAarray, magma_int_t ldda, float **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_slacpy (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const float *dA, magma_int_t ldda, float *dB, magma_int_t lddb)
 

Note

More...
 
void magmablas_slacpy_batched (magma_uplo_t uplo, magma_int_t m, magma_int_t n, const float *const *dAarray, magma_int_t ldda, float **dBarray, magma_int_t lddb, magma_int_t batchCount)
 

Note

More...
 
void magmablas_slag2d (magma_int_t m, magma_int_t n, const float *SA, magma_int_t ldsa, double *A, magma_int_t lda, magma_int_t *info)
 SLAG2D converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION matrix, A. More...
 
float magmablas_slange (magma_norm_t norm, magma_int_t m, magma_int_t n, const float *A, magma_int_t lda, float *dwork)
 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_slansy (magma_norm_t norm, magma_uplo_t uplo, magma_int_t n, const float *A, magma_int_t lda, float *dwork)
 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...
 
void magmablas_sswapdblk (magma_int_t n, magma_int_t nb, float *dA1, magma_int_t ldda1, magma_int_t inca1, float *dA2, magma_int_t ldda2, magma_int_t inca2)
 This is an auxiliary MAGMA routine. More...
 
void magmablas_ssymmetrize (magma_uplo_t uplo, magma_int_t m, float *dA, magma_int_t ldda)
 SSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix. More...
 
void magmablas_ssymmetrize_tiles (magma_uplo_t uplo, magma_int_t m, float *dA, magma_int_t ldda, magma_int_t ntile, magma_int_t mstride, magma_int_t nstride)
 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...
 

Detailed Description

Function Documentation

void magmablas_sgeadd ( magma_int_t  m,
magma_int_t  n,
float  alpha,
const float *  dA,
magma_int_t  ldda,
float *  dB,
magma_int_t  lddb 
)

ZGEADD adds two matrices, dB = alpha*dA + dB.

Parameters
[in]mINTEGER The number of rows of the matrix dA. M >= 0.
[in]nINTEGER The number of columns of the matrix dA. N >= 0.
[in]alphaCOMPLEX REAL The scalar alpha.
[in]dACOMPLEX REAL array, dimension (LDDA,N) The m by n matrix dA.
[in]lddaINTEGER The leading dimension of the array dA. LDDA >= max(1,M).
[in,out]dBCOMPLEX REAL array, dimension (LDDB,N) The m by n matrix dB.
[in]lddbINTEGER The leading dimension of the array dB. LDDB >= max(1,M).
void magmablas_sgeadd_batched ( magma_int_t  m,
magma_int_t  n,
float  alpha,
const float *const *  dAarray,
magma_int_t  ldda,
float **  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.

Parameters
[in]mINTEGER The number of rows of each matrix dAarray[i]. M >= 0.
[in]nINTEGER The number of columns of each matrix dAarray[i]. N >= 0.
[in]alphaCOMPLEX REAL The scalar alpha.
[in]dAarrayarray on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX REAL array, dimension (LDDA,N) The m by n matrices dAarray[i].
[in]lddaINTEGER The leading dimension of each array dAarray[i]. LDDA >= max(1,M).
[in,out]dBarrayarray on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX REAL array, dimension (LDDB,N) The m by n matrices dBarray[i].
[in]lddbINTEGER The leading dimension of each array dBarray[i]. LDDB >= max(1,M).
[in]batchCountINTEGER The number of matrices to add; length of dAarray and dBarray. batchCount >= 0.
void magmablas_slacpy ( magma_uplo_t  uplo,
magma_int_t  m,
magma_int_t  n,
const float *  dA,
magma_int_t  ldda,
float *  dB,
magma_int_t  lddb 
)

Note

  • UPLO Parameter is disabled
  • Do we want to provide a generic function to the user with all the options?

SLACPY copies all or part of a two-dimensional matrix dA to another matrix dB.

Parameters
[in]uplomagma_uplo_t Specifies the part of the matrix dA to be copied to dB.
  • = MagmaUpper: Upper triangular part
  • = MagmaLower: Lower triangular part Otherwise: All of the matrix dA
[in]mINTEGER The number of rows of the matrix dA. M >= 0.
[in]nINTEGER The number of columns of the matrix dA. N >= 0.
[in]dACOMPLEX 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]lddaINTEGER The leading dimension of the array dA. LDDA >= max(1,M).
[out]dBCOMPLEX REAL array, dimension (LDDB,N) The m by n matrix dB. On exit, dB = dA in the locations specified by UPLO.
[in]lddbINTEGER The leading dimension of the array dB. LDDB >= max(1,M).
void magmablas_slacpy_batched ( magma_uplo_t  uplo,
magma_int_t  m,
magma_int_t  n,
const float *const *  dAarray,
magma_int_t  ldda,
float **  dBarray,
magma_int_t  lddb,
magma_int_t  batchCount 
)

Note

  • UPLO Parameter is disabled
  • Do we want to provide a generic function to the user with all the options?

SLACPY 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.

Parameters
[in]uplomagma_uplo_t Specifies the part of each matrix dAarray[i] to be copied to dBarray[i].
  • = MagmaUpper: Upper triangular part
  • = MagmaLower: Lower triangular part Otherwise: All of each matrix dAarray[i]
[in]mINTEGER The number of rows of each matrix dAarray[i]. M >= 0.
[in]nINTEGER The number of columns of each matrix dAarray[i]. N >= 0.
[in]dAarrayarray on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX REAL 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]lddaINTEGER The leading dimension of each array dAarray[i]. LDDA >= max(1,M).
[out]dBarrayarray on GPU, dimension(batchCount), of pointers to arrays, with each array a COMPLEX REAL 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]lddbINTEGER The leading dimension of each array dBarray[i]. LDDB >= max(1,M).
[in]batchCountINTEGER The number of matrices to add; length of dAarray and dBarray. batchCount >= 0.
void magmablas_slag2d ( magma_int_t  m,
magma_int_t  n,
const float *  SA,
magma_int_t  ldsa,
double *  A,
magma_int_t  lda,
magma_int_t *  info 
)

SLAG2D converts a SINGLE PRECISION matrix, SA, to a DOUBLE PRECISION 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.

Parameters
[in]mINTEGER The number of lines of the matrix A. M >= 0.
[in]nINTEGER The number of columns of the matrix A. N >= 0.
[in]SAREAL array, dimension (LDSA,N) On entry, the M-by-N coefficient matrix SA.
[in]ldsaINTEGER The leading dimension of the array SA. LDSA >= max(1,M).
[out]ADOUBLE PRECISION array, dimension (LDA,N) On exit, the M-by-N coefficient matrix A.
[in]ldaINTEGER The leading dimension of the array A. LDA >= max(1,M).
[out]infoINTEGER
  • = 0: successful exit
  • < 0: if INFO = -i, the i-th argument had an illegal value
float magmablas_slange ( magma_norm_t  norm,
magma_int_t  m,
magma_int_t  n,
const float *  A,
magma_int_t  lda,
float *  dwork 
)

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.

Description

SLANGE returns the value

SLANGE = ( 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.

Parameters
[in]normCHARACTER*1 Specifies the value to be returned in SLANGE as described above.
[in]mINTEGER The number of rows of the matrix A. M >= 0. When M = 0, SLANGE is set to zero.
[in]nINTEGER The number of columns of the matrix A. N >= 0. When N = 0, SLANGE is set to zero.
[in]AREAL array on the GPU, dimension (LDA,N) The m by n matrix A.
[in]ldaINTEGER 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_slansy ( magma_norm_t  norm,
magma_uplo_t  uplo,
magma_int_t  n,
const float *  A,
magma_int_t  lda,
float *  dwork 
)

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 = 'M' or 'm' ( ( norm1(A), NORM = '1', 'O' or 'o' ** supported only for CUDA_ARCH >= 200 ( ( normI(A), NORM = 'I' or 'i' ** supported only for 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 SLANSY < 0: if SLANSY = -i, the i-th argument had an illegal value.

Arguments:

Parameters
[in]normCHARACTER*1 Specifies the value to be returned in SLANSY as described above.
[in]uplomagma_uplo_t Specifies whether the upper or lower triangular part of the symmetric matrix A is to be referenced.
  • = MagmaUpper: Upper triangular part of A is referenced
  • = MagmaLower: Lower triangular part of A is referenced
[in]nINTEGER The order of the matrix A. N >= 0. When N = 0, SLANSY is set to zero.
[in]AREAL 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]ldaINTEGER 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 only required for norm1 and normI.
void magmablas_sswapdblk ( magma_int_t  n,
magma_int_t  nb,
float *  dA1,
magma_int_t  ldda1,
magma_int_t  inca1,
float *  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_ssymmetrize ( magma_uplo_t  uplo,
magma_int_t  m,
float *  dA,
magma_int_t  ldda 
)

SSYMMETRIZE copies lower triangle to upper triangle, or vice-versa, to make dA a general representation of a symmetric matrix.

Parameters
[in]uplomagma_uplo_t Specifies the part of the matrix dA that is valid on input.
  • = MagmaUpper: Upper triangular part
  • = MagmaLower: Lower triangular part
[in]mINTEGER The number of rows of the matrix dA. M >= 0.
[in,out]dACOMPLEX REAL array, dimension (LDDA,N) The m by m matrix dA.
[in]lddaINTEGER The leading dimension of the array dA. LDDA >= max(1,M).
void magmablas_ssymmetrize_tiles ( magma_uplo_t  uplo,
magma_int_t  m,
float *  dA,
magma_int_t  ldda,
magma_int_t  ntile,
magma_int_t  mstride,
magma_int_t  nstride 
)

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.

Parameters
[in]uplomagma_uplo_t Specifies the part of the matrix dA that is valid on input.
  • = MagmaUpper: Upper triangular part
  • = MagmaLower: Lower triangular part
[in]mINTEGER The number of rows & columns of each square block of dA. M >= 0.
[in,out]dACOMPLEX REAL array, dimension (LDDA,N) The matrix dA. N = m + nstride*(ntile-1).
[in]lddaINTEGER The leading dimension of the array dA. LDDA >= max(1, m + mstride*(ntile-1)).
[in]ntileINTEGER Number of blocks to symmetrize.
[in]mstrideINTEGER Row offset from start of one block to start of next block.
[in]nstrideINTEGER Column offset from start of one block to start of next block.