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-real matrix, SA, to a double-real 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-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.

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 (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 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 required only for norm1 and normI. Here max-norm also requires work.
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.