MAGMA 2.9.0
Matrix Algebra for GPU and Multicore Architectures
Loading...
Searching...
No Matches
Functions
trmm: Triangular matrix multiply
Batched LA » MAGMA BLAS and Auxiliary » Level 3: matrix-matrix operations, O(n^3) work

\(B = \alpha \;op(A)\; B\) or \(B = \alpha B \;op(A) \) where \(A\) is triangular More...

Functions

void magmablas_ctrmm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_trans_t transA, magma_diag_t diag, magma_int_t *m, magma_int_t *n, magmaFloatComplex alpha, magmaFloatComplex **dA_array, magma_int_t *ldda, magmaFloatComplex **dB_array, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
 CTRMM performs one of the matrix-matrix operations.
 
void magmablas_dtrmm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_trans_t transA, magma_diag_t diag, magma_int_t *m, magma_int_t *n, double alpha, double **dA_array, magma_int_t *ldda, double **dB_array, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
 DTRMM performs one of the matrix-matrix operations.
 
void magmablas_strmm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_trans_t transA, magma_diag_t diag, magma_int_t *m, magma_int_t *n, float alpha, float **dA_array, magma_int_t *ldda, float **dB_array, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
 STRMM performs one of the matrix-matrix operations.
 
void magmablas_ztrmm_vbatched (magma_side_t side, magma_uplo_t uplo, magma_trans_t transA, magma_diag_t diag, magma_int_t *m, magma_int_t *n, magmaDoubleComplex alpha, magmaDoubleComplex **dA_array, magma_int_t *ldda, magmaDoubleComplex **dB_array, magma_int_t *lddb, magma_int_t batchCount, magma_queue_t queue)
 ZTRMM performs one of the matrix-matrix operations.
 

Detailed Description

\(B = \alpha \;op(A)\; B\) or \(B = \alpha B \;op(A) \) where \(A\) is triangular

Function Documentation

◆ magmablas_ctrmm_vbatched()

void magmablas_ctrmm_vbatched ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t transA,
magma_diag_t diag,
magma_int_t * m,
magma_int_t * n,
magmaFloatComplex alpha,
magmaFloatComplex ** dA_array,
magma_int_t * ldda,
magmaFloatComplex ** dB_array,
magma_int_t * lddb,
magma_int_t batchCount,
magma_queue_t queue )

CTRMM performs one of the matrix-matrix operations.

B := alpha*op( A )*B, or B := alpha*B*op( A )

where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of

op( A ) = A or op( A ) = A' or op( A ) = conjg( A' ).

Parameters

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op( A ) multiplies B from the left or right as follows: side = magmaLeft B := alpha*op( A )*B. side = magmaRight B := alpha*B*op( A ). Unchanged on exit.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows: uplo = magmaUpper A is an upper triangular matrix. uplo = magmaLower A is a lower triangular matrix. Unchanged on exit.
[in]transAmagma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows: transA = MagmaNoTrans op( A ) = A. transA = MagmaTrans op( A ) = A'. transA = MagmaConjTrans op( A ) = conjg( A' ). Unchanged on exit.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows: diag = MagmaUnit A is assumed to be unit triangular. diag = MagmaNonUnit A is not assumed to be unit triangular. Unchanged on exit.
[in]mINTEGER array, dimension(batchCount + 1). On entry, each integer M specifies the number of rows of the corresponding matrix B. M must be at least zero. Unchanged on exit.
[in]nINTEGER array, dimension(batchCount + 1). On entry, each integer n specifies the number of columns of the corresponding matrix B. N must be at least zero. Unchanged on exit.
[in]alphaDOUBLE COMPLEX. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. Unchanged on exit.
[in]dA_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array A of DIMENSION ( ldda, k ), where k is M when side = magmaLeft and is N when side = magmaRight. Before entry with uplo = magmaUpper, the leading k by k upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with uplo = magmaLower, the leading k by k lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when diag = MagmaUnit, the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit.
[in]lddaINTEGER array, dimension(batchCount + 1). On entry, ldda specifies the first dimension of A as declared in the calling (sub) program. When side = magmaLeft then ldda must be at least max( 1, M ), when side = magmaRight then ldda must be at least max( 1, N ). Unchanged on exit.
[in,out]dB_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array B of DIMENSION ( lddb, N ). Before entry, the leading M by N part of the array B must contain the matrix B, and on exit is overwritten by the transformed matrix.
[in]lddbINTEGER array, dimension(batchCount + 1). On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. lddb must be at least max( 1, M ). Unchanged on exit.
[in]batchCountINTEGER. The number of matrices to operate on.
[in]queuemagma_queue_t. Queue to execute in.

◆ magmablas_dtrmm_vbatched()

void magmablas_dtrmm_vbatched ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t transA,
magma_diag_t diag,
magma_int_t * m,
magma_int_t * n,
double alpha,
double ** dA_array,
magma_int_t * ldda,
double ** dB_array,
magma_int_t * lddb,
magma_int_t batchCount,
magma_queue_t queue )

DTRMM performs one of the matrix-matrix operations.

B := alpha*op( A )*B, or B := alpha*B*op( A )

where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of

op( A ) = A or op( A ) = A' or op( A ) = conjg( A' ).

Parameters

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op( A ) multiplies B from the left or right as follows: side = magmaLeft B := alpha*op( A )*B. side = magmaRight B := alpha*B*op( A ). Unchanged on exit.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows: uplo = magmaUpper A is an upper triangular matrix. uplo = magmaLower A is a lower triangular matrix. Unchanged on exit.
[in]transAmagma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows: transA = MagmaNoTrans op( A ) = A. transA = MagmaTrans op( A ) = A'. transA = MagmaConjTrans op( A ) = conjg( A' ). Unchanged on exit.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows: diag = MagmaUnit A is assumed to be unit triangular. diag = MagmaNonUnit A is not assumed to be unit triangular. Unchanged on exit.
[in]mINTEGER array, dimension(batchCount + 1). On entry, each integer M specifies the number of rows of the corresponding matrix B. M must be at least zero. Unchanged on exit.
[in]nINTEGER array, dimension(batchCount + 1). On entry, each integer n specifies the number of columns of the corresponding matrix B. N must be at least zero. Unchanged on exit.
[in]alphaDOUBLE COMPLEX. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. Unchanged on exit.
[in]dA_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array A of DIMENSION ( ldda, k ), where k is M when side = magmaLeft and is N when side = magmaRight. Before entry with uplo = magmaUpper, the leading k by k upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with uplo = magmaLower, the leading k by k lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when diag = MagmaUnit, the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit.
[in]lddaINTEGER array, dimension(batchCount + 1). On entry, ldda specifies the first dimension of A as declared in the calling (sub) program. When side = magmaLeft then ldda must be at least max( 1, M ), when side = magmaRight then ldda must be at least max( 1, N ). Unchanged on exit.
[in,out]dB_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array B of DIMENSION ( lddb, N ). Before entry, the leading M by N part of the array B must contain the matrix B, and on exit is overwritten by the transformed matrix.
[in]lddbINTEGER array, dimension(batchCount + 1). On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. lddb must be at least max( 1, M ). Unchanged on exit.
[in]batchCountINTEGER. The number of matrices to operate on.
[in]queuemagma_queue_t. Queue to execute in.

◆ magmablas_strmm_vbatched()

void magmablas_strmm_vbatched ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t transA,
magma_diag_t diag,
magma_int_t * m,
magma_int_t * n,
float alpha,
float ** dA_array,
magma_int_t * ldda,
float ** dB_array,
magma_int_t * lddb,
magma_int_t batchCount,
magma_queue_t queue )

STRMM performs one of the matrix-matrix operations.

B := alpha*op( A )*B, or B := alpha*B*op( A )

where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of

op( A ) = A or op( A ) = A' or op( A ) = conjg( A' ).

Parameters

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op( A ) multiplies B from the left or right as follows: side = magmaLeft B := alpha*op( A )*B. side = magmaRight B := alpha*B*op( A ). Unchanged on exit.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows: uplo = magmaUpper A is an upper triangular matrix. uplo = magmaLower A is a lower triangular matrix. Unchanged on exit.
[in]transAmagma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows: transA = MagmaNoTrans op( A ) = A. transA = MagmaTrans op( A ) = A'. transA = MagmaConjTrans op( A ) = conjg( A' ). Unchanged on exit.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows: diag = MagmaUnit A is assumed to be unit triangular. diag = MagmaNonUnit A is not assumed to be unit triangular. Unchanged on exit.
[in]mINTEGER array, dimension(batchCount + 1). On entry, each integer M specifies the number of rows of the corresponding matrix B. M must be at least zero. Unchanged on exit.
[in]nINTEGER array, dimension(batchCount + 1). On entry, each integer n specifies the number of columns of the corresponding matrix B. N must be at least zero. Unchanged on exit.
[in]alphaDOUBLE COMPLEX. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. Unchanged on exit.
[in]dA_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array A of DIMENSION ( ldda, k ), where k is M when side = magmaLeft and is N when side = magmaRight. Before entry with uplo = magmaUpper, the leading k by k upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with uplo = magmaLower, the leading k by k lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when diag = MagmaUnit, the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit.
[in]lddaINTEGER array, dimension(batchCount + 1). On entry, ldda specifies the first dimension of A as declared in the calling (sub) program. When side = magmaLeft then ldda must be at least max( 1, M ), when side = magmaRight then ldda must be at least max( 1, N ). Unchanged on exit.
[in,out]dB_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array B of DIMENSION ( lddb, N ). Before entry, the leading M by N part of the array B must contain the matrix B, and on exit is overwritten by the transformed matrix.
[in]lddbINTEGER array, dimension(batchCount + 1). On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. lddb must be at least max( 1, M ). Unchanged on exit.
[in]batchCountINTEGER. The number of matrices to operate on.
[in]queuemagma_queue_t. Queue to execute in.

◆ magmablas_ztrmm_vbatched()

void magmablas_ztrmm_vbatched ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t transA,
magma_diag_t diag,
magma_int_t * m,
magma_int_t * n,
magmaDoubleComplex alpha,
magmaDoubleComplex ** dA_array,
magma_int_t * ldda,
magmaDoubleComplex ** dB_array,
magma_int_t * lddb,
magma_int_t batchCount,
magma_queue_t queue )

ZTRMM performs one of the matrix-matrix operations.

B := alpha*op( A )*B, or B := alpha*B*op( A )

where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of

op( A ) = A or op( A ) = A' or op( A ) = conjg( A' ).

Parameters

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op( A ) multiplies B from the left or right as follows: side = magmaLeft B := alpha*op( A )*B. side = magmaRight B := alpha*B*op( A ). Unchanged on exit.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows: uplo = magmaUpper A is an upper triangular matrix. uplo = magmaLower A is a lower triangular matrix. Unchanged on exit.
[in]transAmagma_trans_t. On entry, transA specifies the form of op( A ) to be used in the matrix multiplication as follows: transA = MagmaNoTrans op( A ) = A. transA = MagmaTrans op( A ) = A'. transA = MagmaConjTrans op( A ) = conjg( A' ). Unchanged on exit.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows: diag = MagmaUnit A is assumed to be unit triangular. diag = MagmaNonUnit A is not assumed to be unit triangular. Unchanged on exit.
[in]mINTEGER array, dimension(batchCount + 1). On entry, each integer M specifies the number of rows of the corresponding matrix B. M must be at least zero. Unchanged on exit.
[in]nINTEGER array, dimension(batchCount + 1). On entry, each integer n specifies the number of columns of the corresponding matrix B. N must be at least zero. Unchanged on exit.
[in]alphaDOUBLE COMPLEX. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry. Unchanged on exit.
[in]dA_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array A of DIMENSION ( ldda, k ), where k is M when side = magmaLeft and is N when side = magmaRight. Before entry with uplo = magmaUpper, the leading k by k upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with uplo = magmaLower, the leading k by k lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when diag = MagmaUnit, the diagonal elements of A are not referenced either, but are assumed to be unity. Unchanged on exit.
[in]lddaINTEGER array, dimension(batchCount + 1). On entry, ldda specifies the first dimension of A as declared in the calling (sub) program. When side = magmaLeft then ldda must be at least max( 1, M ), when side = magmaRight then ldda must be at least max( 1, N ). Unchanged on exit.
[in,out]dB_arrayArray of pointers, dimension(batchCount). Each is a DOUBLE COMPLEX array B of DIMENSION ( lddb, N ). Before entry, the leading M by N part of the array B must contain the matrix B, and on exit is overwritten by the transformed matrix.
[in]lddbINTEGER array, dimension(batchCount + 1). On entry, lddb specifies the first dimension of B as declared in the calling (sub) program. lddb must be at least max( 1, M ). Unchanged on exit.
[in]batchCountINTEGER. The number of matrices to operate on.
[in]queuemagma_queue_t. Queue to execute in.