MAGMA 2.9.0
Matrix Algebra for GPU and Multicore Architectures
Loading...
Searching...
No Matches

\(C = op(A)^{-1} B \) or \(C = B \;op(A)^{-1}\) where \(A\) is triangular More...

Functions

magma_int_t magma_ctrsm_m (magma_int_t ngpu, 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, const magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *B, magma_int_t ldb)
 CTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of.
 
magma_int_t magma_dtrsm_m (magma_int_t ngpu, 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, const double *A, magma_int_t lda, double *B, magma_int_t ldb)
 DTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of.
 
magma_int_t magma_strsm_m (magma_int_t ngpu, 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, const float *A, magma_int_t lda, float *B, magma_int_t ldb)
 STRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of.
 
magma_int_t magma_ztrsm_m (magma_int_t ngpu, 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, const magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *B, magma_int_t ldb)
 ZTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of.
 
void magma_ctrsm (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Solve triangular matrix-matrix system (multiple right-hand sides).
 
void magma_dtrsm (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag, magma_int_t m, magma_int_t n, double alpha, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Solve triangular matrix-matrix system (multiple right-hand sides).
 
void magma_strsm (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag, magma_int_t m, magma_int_t n, float alpha, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Solve triangular matrix-matrix system (multiple right-hand sides).
 
void magma_ztrsm (magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Solve triangular matrix-matrix system (multiple right-hand sides).
 
void magmablas_ctrsm_outofplace (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_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex_ptr dX, magma_int_t lddx, magma_int_t flag, magmaFloatComplex_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 ctrsm_outofplace solves one of the matrix equations on gpu
 
void magmablas_ctrsm_work (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_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magmaFloatComplex_ptr dX, magma_int_t lddx, magma_int_t flag, magmaFloatComplex_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 Similar to magmablas_ctrsm_outofplace(), but copies result dX back to dB, as in classical ctrsm interface.
 
void magmablas_ctrsm (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_const_ptr dA, magma_int_t ldda, magmaFloatComplex_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Similar to magmablas_ctrsm_outofplace(), but allocates dX and d_dinvA internally.
 
void magmablas_dtrsm_outofplace (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, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, magmaDouble_ptr dX, magma_int_t lddx, magma_int_t flag, magmaDouble_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 dtrsm_outofplace solves one of the matrix equations on gpu
 
void magmablas_dtrsm_work (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, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, magmaDouble_ptr dX, magma_int_t lddx, magma_int_t flag, magmaDouble_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 Similar to magmablas_dtrsm_outofplace(), but copies result dX back to dB, as in classical dtrsm interface.
 
void magmablas_dtrsm (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, magmaDouble_const_ptr dA, magma_int_t ldda, magmaDouble_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Similar to magmablas_dtrsm_outofplace(), but allocates dX and d_dinvA internally.
 
void magmablas_strsm_outofplace (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, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magmaFloat_ptr dX, magma_int_t lddx, magma_int_t flag, magmaFloat_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 strsm_outofplace solves one of the matrix equations on gpu
 
void magmablas_strsm_work (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, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magmaFloat_ptr dX, magma_int_t lddx, magma_int_t flag, magmaFloat_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 Similar to magmablas_strsm_outofplace(), but copies result dX back to dB, as in classical strsm interface.
 
void magmablas_strsm (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, magmaFloat_const_ptr dA, magma_int_t ldda, magmaFloat_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Similar to magmablas_strsm_outofplace(), but allocates dX and d_dinvA internally.
 
void magmablas_ztrsm_outofplace (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_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex_ptr dX, magma_int_t lddx, magma_int_t flag, magmaDoubleComplex_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 ztrsm_outofplace solves one of the matrix equations on gpu
 
void magmablas_ztrsm_work (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_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magmaDoubleComplex_ptr dX, magma_int_t lddx, magma_int_t flag, magmaDoubleComplex_ptr d_dinvA, magma_int_t dinvA_length, magma_queue_t queue)
 Similar to magmablas_ztrsm_outofplace(), but copies result dX back to dB, as in classical ztrsm interface.
 
void magmablas_ztrsm (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_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_ptr dB, magma_int_t lddb, magma_queue_t queue)
 Similar to magmablas_ztrsm_outofplace(), but allocates dX and d_dinvA internally.
 

Detailed Description

\(C = op(A)^{-1} B \) or \(C = B \;op(A)^{-1}\) where \(A\) is triangular

Function Documentation

◆ magma_ctrsm_m()

magma_int_t magma_ctrsm_m ( magma_int_t ngpu,
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,
const magmaFloatComplex * A,
magma_int_t lda,
magmaFloatComplex * B,
magma_int_t ldb )

CTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, 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**T   or
op( A ) = A**H.

The matrix X is overwritten on B.

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]sidemagma_side_t. On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows:
  • = MagmaLeft: op( A )*X = alpha*B.
  • = MagmaRight: X*op( A ) = alpha*B.
[in]uplomagma_uplo_t. On entry, UPLO specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transamagma_trans_t. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op( A ) = A.
  • = MagmaTrans: op( A ) = A**T.
  • = MagmaConjTrans: op( A ) = A**H.
[in]diagmagma_diag_t. On entry, DIAG specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, M specifies the number of rows of B. M must be at least zero.
[in]nINTEGER. On entry, N specifies the number of columns of B. N must be at least zero.
[in]alphaCOMPLEX. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]ACOMPLEX array of DIMENSION ( LDA, 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.
[in]ldaINTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = MagmaLeft then LDA >= max( 1, m ), when SIDE = MagmaRight then LDA >= max( 1, n ).
[in,out]BCOMPLEX array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B, and on exit is overwritten by the solution matrix X.
[in]ldbINTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ).

◆ magma_dtrsm_m()

magma_int_t magma_dtrsm_m ( magma_int_t ngpu,
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,
const double * A,
magma_int_t lda,
double * B,
magma_int_t ldb )

DTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, 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**T   or
op( A ) = A**H.

The matrix X is overwritten on B.

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]sidemagma_side_t. On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows:
  • = MagmaLeft: op( A )*X = alpha*B.
  • = MagmaRight: X*op( A ) = alpha*B.
[in]uplomagma_uplo_t. On entry, UPLO specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transamagma_trans_t. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op( A ) = A.
  • = MagmaTrans: op( A ) = A**T.
  • = MagmaConjTrans: op( A ) = A**H.
[in]diagmagma_diag_t. On entry, DIAG specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, M specifies the number of rows of B. M must be at least zero.
[in]nINTEGER. On entry, N specifies the number of columns of B. N must be at least zero.
[in]alphaDOUBLE PRECISION. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]ADOUBLE PRECISION array of DIMENSION ( LDA, 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.
[in]ldaINTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = MagmaLeft then LDA >= max( 1, m ), when SIDE = MagmaRight then LDA >= max( 1, n ).
[in,out]BDOUBLE PRECISION array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B, and on exit is overwritten by the solution matrix X.
[in]ldbINTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ).

◆ magma_strsm_m()

magma_int_t magma_strsm_m ( magma_int_t ngpu,
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,
const float * A,
magma_int_t lda,
float * B,
magma_int_t ldb )

STRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, 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**T   or
op( A ) = A**H.

The matrix X is overwritten on B.

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]sidemagma_side_t. On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows:
  • = MagmaLeft: op( A )*X = alpha*B.
  • = MagmaRight: X*op( A ) = alpha*B.
[in]uplomagma_uplo_t. On entry, UPLO specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transamagma_trans_t. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op( A ) = A.
  • = MagmaTrans: op( A ) = A**T.
  • = MagmaConjTrans: op( A ) = A**H.
[in]diagmagma_diag_t. On entry, DIAG specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, M specifies the number of rows of B. M must be at least zero.
[in]nINTEGER. On entry, N specifies the number of columns of B. N must be at least zero.
[in]alphaREAL. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]AREAL array of DIMENSION ( LDA, 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.
[in]ldaINTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = MagmaLeft then LDA >= max( 1, m ), when SIDE = MagmaRight then LDA >= max( 1, n ).
[in,out]BREAL array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B, and on exit is overwritten by the solution matrix X.
[in]ldbINTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ).

◆ magma_ztrsm_m()

magma_int_t magma_ztrsm_m ( magma_int_t ngpu,
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,
const magmaDoubleComplex * A,
magma_int_t lda,
magmaDoubleComplex * B,
magma_int_t ldb )

ZTRSM solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, 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**T   or
op( A ) = A**H.

The matrix X is overwritten on B.

Parameters
[in]ngpuINTEGER Number of GPUs to use. ngpu > 0.
[in]sidemagma_side_t. On entry, SIDE specifies whether op( A ) appears on the left or right of X as follows:
  • = MagmaLeft: op( A )*X = alpha*B.
  • = MagmaRight: X*op( A ) = alpha*B.
[in]uplomagma_uplo_t. On entry, UPLO specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transamagma_trans_t. On entry, TRANSA specifies the form of op( A ) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op( A ) = A.
  • = MagmaTrans: op( A ) = A**T.
  • = MagmaConjTrans: op( A ) = A**H.
[in]diagmagma_diag_t. On entry, DIAG specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, M specifies the number of rows of B. M must be at least zero.
[in]nINTEGER. On entry, N specifies the number of columns of B. N must be at least zero.
[in]alphaCOMPLEX_16. On entry, ALPHA specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]ACOMPLEX_16 array of DIMENSION ( LDA, 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.
[in]ldaINTEGER. On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. When SIDE = MagmaLeft then LDA >= max( 1, m ), when SIDE = MagmaRight then LDA >= max( 1, n ).
[in,out]BCOMPLEX_16 array of DIMENSION ( LDB, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B, and on exit is overwritten by the solution matrix X.
[in]ldbINTEGER. On entry, LDB specifies the first dimension of B as declared in the calling (sub) program. LDB must be at least max( 1, m ).

◆ magma_ctrsm()

void magma_ctrsm ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t trans,
magma_diag_t diag,
magma_int_t m,
magma_int_t n,
magmaFloatComplex alpha,
magmaFloatComplex_const_ptr dA,
magma_int_t ldda,
magmaFloatComplex_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Solve triangular matrix-matrix system (multiple right-hand sides).

\( op(A) X = \alpha B \) (side == MagmaLeft), or
\( X op(A) = \alpha B \) (side == MagmaRight),
where \( A \) is triangular.

Parameters
[in]sideWhether A is on the left or right.
[in]uploWhether A is upper or lower triangular.
[in]transOperation to perform on A.
[in]diagWhether the diagonal of A is assumed to be unit or non-unit.
[in]mNumber of rows of B. m >= 0.
[in]nNumber of columns of B. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dACOMPLEX array on GPU device. If side == MagmaLeft, the m-by-m triangular matrix A of dimension (ldda,m), ldda >= max(1,m);
otherwise, the n-by-n triangular matrix A of dimension (ldda,n), ldda >= max(1,n).
[in]lddaLeading dimension of dA.
[in,out]dBCOMPLEX array on GPU device. On entry, m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m). On exit, overwritten with the solution matrix X.
[in]lddbLeading dimension of dB.
[in]queuemagma_queue_t Queue to execute in.

◆ magma_dtrsm()

void magma_dtrsm ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t trans,
magma_diag_t diag,
magma_int_t m,
magma_int_t n,
double alpha,
magmaDouble_const_ptr dA,
magma_int_t ldda,
magmaDouble_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Solve triangular matrix-matrix system (multiple right-hand sides).

\( op(A) X = \alpha B \) (side == MagmaLeft), or
\( X op(A) = \alpha B \) (side == MagmaRight),
where \( A \) is triangular.

Parameters
[in]sideWhether A is on the left or right.
[in]uploWhether A is upper or lower triangular.
[in]transOperation to perform on A.
[in]diagWhether the diagonal of A is assumed to be unit or non-unit.
[in]mNumber of rows of B. m >= 0.
[in]nNumber of columns of B. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dADOUBLE PRECISION array on GPU device. If side == MagmaLeft, the m-by-m triangular matrix A of dimension (ldda,m), ldda >= max(1,m);
otherwise, the n-by-n triangular matrix A of dimension (ldda,n), ldda >= max(1,n).
[in]lddaLeading dimension of dA.
[in,out]dBDOUBLE PRECISION array on GPU device. On entry, m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m). On exit, overwritten with the solution matrix X.
[in]lddbLeading dimension of dB.
[in]queuemagma_queue_t Queue to execute in.

◆ magma_strsm()

void magma_strsm ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t trans,
magma_diag_t diag,
magma_int_t m,
magma_int_t n,
float alpha,
magmaFloat_const_ptr dA,
magma_int_t ldda,
magmaFloat_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Solve triangular matrix-matrix system (multiple right-hand sides).

\( op(A) X = \alpha B \) (side == MagmaLeft), or
\( X op(A) = \alpha B \) (side == MagmaRight),
where \( A \) is triangular.

Parameters
[in]sideWhether A is on the left or right.
[in]uploWhether A is upper or lower triangular.
[in]transOperation to perform on A.
[in]diagWhether the diagonal of A is assumed to be unit or non-unit.
[in]mNumber of rows of B. m >= 0.
[in]nNumber of columns of B. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dAREAL array on GPU device. If side == MagmaLeft, the m-by-m triangular matrix A of dimension (ldda,m), ldda >= max(1,m);
otherwise, the n-by-n triangular matrix A of dimension (ldda,n), ldda >= max(1,n).
[in]lddaLeading dimension of dA.
[in,out]dBREAL array on GPU device. On entry, m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m). On exit, overwritten with the solution matrix X.
[in]lddbLeading dimension of dB.
[in]queuemagma_queue_t Queue to execute in.

◆ magma_ztrsm()

void magma_ztrsm ( magma_side_t side,
magma_uplo_t uplo,
magma_trans_t trans,
magma_diag_t diag,
magma_int_t m,
magma_int_t n,
magmaDoubleComplex alpha,
magmaDoubleComplex_const_ptr dA,
magma_int_t ldda,
magmaDoubleComplex_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Solve triangular matrix-matrix system (multiple right-hand sides).

\( op(A) X = \alpha B \) (side == MagmaLeft), or
\( X op(A) = \alpha B \) (side == MagmaRight),
where \( A \) is triangular.

Parameters
[in]sideWhether A is on the left or right.
[in]uploWhether A is upper or lower triangular.
[in]transOperation to perform on A.
[in]diagWhether the diagonal of A is assumed to be unit or non-unit.
[in]mNumber of rows of B. m >= 0.
[in]nNumber of columns of B. n >= 0.
[in]alphaScalar \( \alpha \)
[in]dACOMPLEX_16 array on GPU device. If side == MagmaLeft, the m-by-m triangular matrix A of dimension (ldda,m), ldda >= max(1,m);
otherwise, the n-by-n triangular matrix A of dimension (ldda,n), ldda >= max(1,n).
[in]lddaLeading dimension of dA.
[in,out]dBCOMPLEX_16 array on GPU device. On entry, m-by-n matrix B of dimension (lddb,n), lddb >= max(1,m). On exit, overwritten with the solution matrix X.
[in]lddbLeading dimension of dB.
[in]queuemagma_queue_t Queue to execute in.

◆ magmablas_ctrsm_outofplace()

void magmablas_ctrsm_outofplace ( 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_const_ptr dA,
magma_int_t ldda,
magmaFloatComplex_ptr dB,
magma_int_t lddb,
magmaFloatComplex_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaFloatComplex_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

ctrsm_outofplace solves one of the matrix equations on gpu

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

where alpha is a scalar, X and B are m by n matrices, 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^T,  or
op(A) = A^H.

The matrix X is output.

This is an asynchronous version of magmablas_ctrsm with flag, d_dinvA and dX workspaces as arguments.

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op(A) appears on the left or right of X as follows:
  • = MagmaLeft: op(A)*X = alpha*B.
  • = MagmaRight: X*op(A) = alpha*B.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transAmagma_trans_t. On entry, transA specifies the form of op(A) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op(A) = A.
  • = MagmaTrans: op(A) = A^T.
  • = MagmaConjTrans: op(A) = A^H.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, m specifies the number of rows of B. m >= 0.
[in]nINTEGER. On entry, n specifies the number of columns of B. n >= 0.
[in]alphaCOMPLEX. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]dACOMPLEX array 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.
[in]lddaINTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ).
[in]dBCOMPLEX array of dimension ( lddb, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B. On exit, contents in the leading m by n part are destroyed.
[in]lddbINTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ).
[out]dXCOMPLEX array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X.
[in]lddxINTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ).
[in]flagBOOLEAN. If flag is true, invert diagonal blocks. If flag is false, assume diagonal blocks (stored in d_dinvA) are already inverted.
d_dinvA(workspace) on device. If side == MagmaLeft, d_dinvA must be of size dinvA_length >= ceil(m/NB)*NB*NB, If side == MagmaRight, d_dinvA must be of size dinvA_length >= ceil(n/NB)*NB*NB, where NB = 128.
[in]dinvA_lengthINTEGER. On entry, dinvA_length specifies the size of d_dinvA.
[in]queuemagma_queue_t Queue to execute in.

◆ magmablas_ctrsm_work()

void magmablas_ctrsm_work ( 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_const_ptr dA,
magma_int_t ldda,
magmaFloatComplex_ptr dB,
magma_int_t lddb,
magmaFloatComplex_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaFloatComplex_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

Similar to magmablas_ctrsm_outofplace(), but copies result dX back to dB, as in classical ctrsm interface.

See also
magmablas_ctrsm_outofplace

◆ magmablas_ctrsm()

void magmablas_ctrsm ( 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_const_ptr dA,
magma_int_t ldda,
magmaFloatComplex_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Similar to magmablas_ctrsm_outofplace(), but allocates dX and d_dinvA internally.

This makes it a synchronous call, whereas magmablas_ctrsm_outofplace() and magmablas_ctrsm_work() are asynchronous.

See also
magmablas_ctrsm_work

◆ magmablas_dtrsm_outofplace()

void magmablas_dtrsm_outofplace ( 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,
magmaDouble_const_ptr dA,
magma_int_t ldda,
magmaDouble_ptr dB,
magma_int_t lddb,
magmaDouble_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaDouble_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

dtrsm_outofplace solves one of the matrix equations on gpu

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

where alpha is a scalar, X and B are m by n matrices, 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^T,  or
op(A) = A^H.

The matrix X is output.

This is an asynchronous version of magmablas_dtrsm with flag, d_dinvA and dX workspaces as arguments.

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op(A) appears on the left or right of X as follows:
  • = MagmaLeft: op(A)*X = alpha*B.
  • = MagmaRight: X*op(A) = alpha*B.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transAmagma_trans_t. On entry, transA specifies the form of op(A) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op(A) = A.
  • = MagmaTrans: op(A) = A^T.
  • = MagmaConjTrans: op(A) = A^H.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, m specifies the number of rows of B. m >= 0.
[in]nINTEGER. On entry, n specifies the number of columns of B. n >= 0.
[in]alphaDOUBLE PRECISION. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]dADOUBLE PRECISION array 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.
[in]lddaINTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ).
[in]dBDOUBLE PRECISION array of dimension ( lddb, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B. On exit, contents in the leading m by n part are destroyed.
[in]lddbINTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ).
[out]dXDOUBLE PRECISION array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X.
[in]lddxINTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ).
[in]flagBOOLEAN. If flag is true, invert diagonal blocks. If flag is false, assume diagonal blocks (stored in d_dinvA) are already inverted.
d_dinvA(workspace) on device. If side == MagmaLeft, d_dinvA must be of size dinvA_length >= ceil(m/NB)*NB*NB, If side == MagmaRight, d_dinvA must be of size dinvA_length >= ceil(n/NB)*NB*NB, where NB = 128.
[in]dinvA_lengthINTEGER. On entry, dinvA_length specifies the size of d_dinvA.
[in]queuemagma_queue_t Queue to execute in.

◆ magmablas_dtrsm_work()

void magmablas_dtrsm_work ( 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,
magmaDouble_const_ptr dA,
magma_int_t ldda,
magmaDouble_ptr dB,
magma_int_t lddb,
magmaDouble_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaDouble_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

Similar to magmablas_dtrsm_outofplace(), but copies result dX back to dB, as in classical dtrsm interface.

See also
magmablas_dtrsm_outofplace

◆ magmablas_dtrsm()

void magmablas_dtrsm ( 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,
magmaDouble_const_ptr dA,
magma_int_t ldda,
magmaDouble_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Similar to magmablas_dtrsm_outofplace(), but allocates dX and d_dinvA internally.

This makes it a synchronous call, whereas magmablas_dtrsm_outofplace() and magmablas_dtrsm_work() are asynchronous.

See also
magmablas_dtrsm_work

◆ magmablas_strsm_outofplace()

void magmablas_strsm_outofplace ( 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,
magmaFloat_const_ptr dA,
magma_int_t ldda,
magmaFloat_ptr dB,
magma_int_t lddb,
magmaFloat_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaFloat_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

strsm_outofplace solves one of the matrix equations on gpu

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

where alpha is a scalar, X and B are m by n matrices, 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^T,  or
op(A) = A^H.

The matrix X is output.

This is an asynchronous version of magmablas_strsm with flag, d_dinvA and dX workspaces as arguments.

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op(A) appears on the left or right of X as follows:
  • = MagmaLeft: op(A)*X = alpha*B.
  • = MagmaRight: X*op(A) = alpha*B.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transAmagma_trans_t. On entry, transA specifies the form of op(A) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op(A) = A.
  • = MagmaTrans: op(A) = A^T.
  • = MagmaConjTrans: op(A) = A^H.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, m specifies the number of rows of B. m >= 0.
[in]nINTEGER. On entry, n specifies the number of columns of B. n >= 0.
[in]alphaREAL. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]dAREAL array 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.
[in]lddaINTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ).
[in]dBREAL array of dimension ( lddb, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B. On exit, contents in the leading m by n part are destroyed.
[in]lddbINTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ).
[out]dXREAL array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X.
[in]lddxINTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ).
[in]flagBOOLEAN. If flag is true, invert diagonal blocks. If flag is false, assume diagonal blocks (stored in d_dinvA) are already inverted.
d_dinvA(workspace) on device. If side == MagmaLeft, d_dinvA must be of size dinvA_length >= ceil(m/NB)*NB*NB, If side == MagmaRight, d_dinvA must be of size dinvA_length >= ceil(n/NB)*NB*NB, where NB = 128.
[in]dinvA_lengthINTEGER. On entry, dinvA_length specifies the size of d_dinvA.
[in]queuemagma_queue_t Queue to execute in.

◆ magmablas_strsm_work()

void magmablas_strsm_work ( 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,
magmaFloat_const_ptr dA,
magma_int_t ldda,
magmaFloat_ptr dB,
magma_int_t lddb,
magmaFloat_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaFloat_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

Similar to magmablas_strsm_outofplace(), but copies result dX back to dB, as in classical strsm interface.

See also
magmablas_strsm_outofplace

◆ magmablas_strsm()

void magmablas_strsm ( 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,
magmaFloat_const_ptr dA,
magma_int_t ldda,
magmaFloat_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Similar to magmablas_strsm_outofplace(), but allocates dX and d_dinvA internally.

This makes it a synchronous call, whereas magmablas_strsm_outofplace() and magmablas_strsm_work() are asynchronous.

See also
magmablas_strsm_work

◆ magmablas_ztrsm_outofplace()

void magmablas_ztrsm_outofplace ( 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_const_ptr dA,
magma_int_t ldda,
magmaDoubleComplex_ptr dB,
magma_int_t lddb,
magmaDoubleComplex_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaDoubleComplex_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

ztrsm_outofplace solves one of the matrix equations on gpu

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

where alpha is a scalar, X and B are m by n matrices, 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^T,  or
op(A) = A^H.

The matrix X is output.

This is an asynchronous version of magmablas_ztrsm with flag, d_dinvA and dX workspaces as arguments.

Parameters
[in]sidemagma_side_t. On entry, side specifies whether op(A) appears on the left or right of X as follows:
  • = MagmaLeft: op(A)*X = alpha*B.
  • = MagmaRight: X*op(A) = alpha*B.
[in]uplomagma_uplo_t. On entry, uplo specifies whether the matrix A is an upper or lower triangular matrix as follows:
  • = MagmaUpper: A is an upper triangular matrix.
  • = MagmaLower: A is a lower triangular matrix.
[in]transAmagma_trans_t. On entry, transA specifies the form of op(A) to be used in the matrix multiplication as follows:
  • = MagmaNoTrans: op(A) = A.
  • = MagmaTrans: op(A) = A^T.
  • = MagmaConjTrans: op(A) = A^H.
[in]diagmagma_diag_t. On entry, diag specifies whether or not A is unit triangular as follows:
  • = MagmaUnit: A is assumed to be unit triangular.
  • = MagmaNonUnit: A is not assumed to be unit triangular.
[in]mINTEGER. On entry, m specifies the number of rows of B. m >= 0.
[in]nINTEGER. On entry, n specifies the number of columns of B. n >= 0.
[in]alphaCOMPLEX_16. On entry, alpha specifies the scalar alpha. When alpha is zero then A is not referenced and B need not be set before entry.
[in]dACOMPLEX_16 array 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.
[in]lddaINTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ).
[in]dBCOMPLEX_16 array of dimension ( lddb, n ). Before entry, the leading m by n part of the array B must contain the right-hand side matrix B. On exit, contents in the leading m by n part are destroyed.
[in]lddbINTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ).
[out]dXCOMPLEX_16 array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X.
[in]lddxINTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ).
[in]flagBOOLEAN. If flag is true, invert diagonal blocks. If flag is false, assume diagonal blocks (stored in d_dinvA) are already inverted.
d_dinvA(workspace) on device. If side == MagmaLeft, d_dinvA must be of size dinvA_length >= ceil(m/NB)*NB*NB, If side == MagmaRight, d_dinvA must be of size dinvA_length >= ceil(n/NB)*NB*NB, where NB = 128.
[in]dinvA_lengthINTEGER. On entry, dinvA_length specifies the size of d_dinvA.
[in]queuemagma_queue_t Queue to execute in.

◆ magmablas_ztrsm_work()

void magmablas_ztrsm_work ( 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_const_ptr dA,
magma_int_t ldda,
magmaDoubleComplex_ptr dB,
magma_int_t lddb,
magmaDoubleComplex_ptr dX,
magma_int_t lddx,
magma_int_t flag,
magmaDoubleComplex_ptr d_dinvA,
magma_int_t dinvA_length,
magma_queue_t queue )

Similar to magmablas_ztrsm_outofplace(), but copies result dX back to dB, as in classical ztrsm interface.

See also
magmablas_ztrsm_outofplace

◆ magmablas_ztrsm()

void magmablas_ztrsm ( 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_const_ptr dA,
magma_int_t ldda,
magmaDoubleComplex_ptr dB,
magma_int_t lddb,
magma_queue_t queue )

Similar to magmablas_ztrsm_outofplace(), but allocates dX and d_dinvA internally.

This makes it a synchronous call, whereas magmablas_ztrsm_outofplace() and magmablas_ztrsm_work() are asynchronous.

See also
magmablas_ztrsm_work