 MAGMA  2.5.4 Matrix Algebra for GPU and Multicore Architectures
trsm: Triangular solve matrix

$$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. More...

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

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

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

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). More...

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). More...

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). More...

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). More...

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

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

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

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

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

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

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

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

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

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

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

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

## Detailed Description

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

## ◆ 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] ngpu INTEGER Number of GPUs to use. ngpu > 0. [in] side magma_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] uplo magma_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] transa magma_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] diag magma_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] m INTEGER. On entry, M specifies the number of rows of B. M must be at least zero. [in] n INTEGER. On entry, N specifies the number of columns of B. N must be at least zero. [in] alpha 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. [in] A COMPLEX 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] lda INTEGER. 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] B COMPLEX 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] ldb INTEGER. 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] ngpu INTEGER Number of GPUs to use. ngpu > 0. [in] side magma_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] uplo magma_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] transa magma_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] diag magma_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] m INTEGER. On entry, M specifies the number of rows of B. M must be at least zero. [in] n INTEGER. On entry, N specifies the number of columns of B. N must be at least zero. [in] alpha DOUBLE 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] A DOUBLE 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] lda INTEGER. 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] B DOUBLE 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] ldb INTEGER. 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] ngpu INTEGER Number of GPUs to use. ngpu > 0. [in] side magma_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] uplo magma_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] transa magma_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] diag magma_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] m INTEGER. On entry, M specifies the number of rows of B. M must be at least zero. [in] n INTEGER. On entry, N specifies the number of columns of B. N must be at least zero. [in] alpha REAL. 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] A REAL 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] lda INTEGER. 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] B REAL 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] ldb INTEGER. 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] ngpu INTEGER Number of GPUs to use. ngpu > 0. [in] side magma_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] uplo magma_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] transa magma_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] diag magma_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] m INTEGER. On entry, M specifies the number of rows of B. M must be at least zero. [in] n INTEGER. On entry, N specifies the number of columns of B. N must be at least zero. [in] alpha COMPLEX_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] A COMPLEX_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] lda INTEGER. 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] B COMPLEX_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] ldb INTEGER. 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] side Whether A is on the left or right. [in] uplo Whether A is upper or lower triangular. [in] trans Operation to perform on A. [in] diag Whether the diagonal of A is assumed to be unit or non-unit. [in] m Number of rows of B. m >= 0. [in] n Number of columns of B. n >= 0. [in] alpha Scalar $$\alpha$$ [in] dA COMPLEX 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] ldda Leading dimension of dA. [in,out] dB COMPLEX 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] lddb Leading dimension of dB. [in] queue magma_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] side Whether A is on the left or right. [in] uplo Whether A is upper or lower triangular. [in] trans Operation to perform on A. [in] diag Whether the diagonal of A is assumed to be unit or non-unit. [in] m Number of rows of B. m >= 0. [in] n Number of columns of B. n >= 0. [in] alpha Scalar $$\alpha$$ [in] dA DOUBLE 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] ldda Leading dimension of dA. [in,out] dB DOUBLE 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] lddb Leading dimension of dB. [in] queue magma_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] side Whether A is on the left or right. [in] uplo Whether A is upper or lower triangular. [in] trans Operation to perform on A. [in] diag Whether the diagonal of A is assumed to be unit or non-unit. [in] m Number of rows of B. m >= 0. [in] n Number of columns of B. n >= 0. [in] alpha Scalar $$\alpha$$ [in] dA REAL 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] ldda Leading dimension of dA. [in,out] dB REAL 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] lddb Leading dimension of dB. [in] queue magma_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] side Whether A is on the left or right. [in] uplo Whether A is upper or lower triangular. [in] trans Operation to perform on A. [in] diag Whether the diagonal of A is assumed to be unit or non-unit. [in] m Number of rows of B. m >= 0. [in] n Number of columns of B. n >= 0. [in] alpha Scalar $$\alpha$$ [in] dA COMPLEX_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] ldda Leading dimension of dA. [in,out] dB COMPLEX_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] lddb Leading dimension of dB. [in] queue magma_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] side magma_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] uplo magma_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] transA magma_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] diag magma_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] m INTEGER. On entry, m specifies the number of rows of B. m >= 0. [in] n INTEGER. On entry, n specifies the number of columns of B. n >= 0. [in] alpha 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. [in] dA COMPLEX 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] ldda INTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ). [in] dB COMPLEX 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] lddb INTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ). [out] dX COMPLEX array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X. [in] lddx INTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ). [in] flag BOOLEAN. 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_length INTEGER. On entry, dinvA_length specifies the size of d_dinvA. [in] queue magma_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.

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.

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] side magma_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] uplo magma_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] transA magma_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] diag magma_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] m INTEGER. On entry, m specifies the number of rows of B. m >= 0. [in] n INTEGER. On entry, n specifies the number of columns of B. n >= 0. [in] alpha DOUBLE 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] dA DOUBLE 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] ldda INTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ). [in] dB DOUBLE 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] lddb INTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ). [out] dX DOUBLE PRECISION array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X. [in] lddx INTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ). [in] flag BOOLEAN. 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_length INTEGER. On entry, dinvA_length specifies the size of d_dinvA. [in] queue magma_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.

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.

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] side magma_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] uplo magma_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] transA magma_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] diag magma_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] m INTEGER. On entry, m specifies the number of rows of B. m >= 0. [in] n INTEGER. On entry, n specifies the number of columns of B. n >= 0. [in] alpha REAL. 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] dA REAL 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] ldda INTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ). [in] dB REAL 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] lddb INTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ). [out] dX REAL array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X. [in] lddx INTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ). [in] flag BOOLEAN. 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_length INTEGER. On entry, dinvA_length specifies the size of d_dinvA. [in] queue magma_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.

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.

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] side magma_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] uplo magma_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] transA magma_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] diag magma_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] m INTEGER. On entry, m specifies the number of rows of B. m >= 0. [in] n INTEGER. On entry, n specifies the number of columns of B. n >= 0. [in] alpha COMPLEX_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] dA COMPLEX_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] ldda INTEGER. On entry, ldda specifies the first dimension of A. When side = MagmaLeft, ldda >= max( 1, m ), when side = MagmaRight, ldda >= max( 1, n ). [in] dB COMPLEX_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] lddb INTEGER. On entry, lddb specifies the first dimension of B. lddb >= max( 1, m ). [out] dX COMPLEX_16 array of dimension ( lddx, n ). On exit, it contains the m by n solution matrix X. [in] lddx INTEGER. On entry, lddx specifies the first dimension of X. lddx >= max( 1, m ). [in] flag BOOLEAN. 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_length INTEGER. On entry, dinvA_length specifies the size of d_dinvA. [in] queue magma_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.