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

Function Documentation

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

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.

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.

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.

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.

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.

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

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

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.

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

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

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.

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

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

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.

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

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