JCublasJava/src/main/java/jcuda/jcublas/JCublas.java
public static void cublasDtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, Pointer A, int lda, Pointer B, int ldb)
    {
        cublasDtrsmNative(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
        checkResultBLAS();
    }
public static void cublasDtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, Pointer A, int lda, Pointer B, int ldb)
    {
        cublasDtrsmNative(side, uplo, transa, diag, m, n, alpha, A, lda, B, ldb);
        checkResultBLAS();
    }
<pre>
void
cublasDtrsm (char side, char uplo, char transa, char diag, int m, int n,
double alpha, const double *A, int lda, double *B, int ldb)

solves one of the matrix equations

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

where alpha is a double precision scalar, and X and B are m x n matrices
that are composed of double precision elements. A is a unit or non-unit,
upper or lower triangular matrix, and op(A) is one of

op(A) = A  or  op(A) = transpose(A)

The result matrix X overwrites input matrix B; that is, on exit the result
is stored in B. Matrices A and B are stored in column major format, and
lda and ldb are the leading dimensions of the two-dimensonials arrays that
contain A and B, respectively.

Input
-----
side   specifies whether op(A) appears on the left or right of X as
follows: side = 'L' or 'l' indicates solve op(A) * X = alpha * B.
side = 'R' or 'r' indicates solve X * op(A) = alpha * B.
uplo   specifies whether the matrix A is an upper or lower triangular
matrix as follows: uplo = 'U' or 'u' indicates A is an upper
triangular matrix. uplo = 'L' or 'l' indicates A is a lower
triangular matrix.
transa specifies the form of op(A) to be used in matrix multiplication
as follows: If transa = 'N' or 'N', then op(A) = A. If transa =
'T', 't', 'C', or 'c', then op(A) = transpose(A).
diag   specifies whether or not A is a unit triangular matrix like so:
if diag = 'U' or 'u', A is assumed to be unit triangular. If
diag = 'N' or 'n', then A is not assumed to be unit triangular.
m      specifies the number of rows of B. m must be at least zero.
n      specifies the number of columns of B. n must be at least zero.
alpha  is a double precision scalar to be multiplied with B. When alpha is
zero, then A is not referenced and B need not be set before entry.
A      is a double precision array of dimensions (lda, k), where k is
m when side = 'L' or 'l', and is n when side = 'R' or 'r'. If
uplo = 'U' or 'u', the leading k x k upper triangular part of
the array A must contain the upper triangular matrix and the
strictly lower triangular matrix of A is not referenced. When
uplo = 'L' or 'l', the leading k x 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 = 'U' or 'u', the diagonal elements of A are not
referenced, and are assumed to be unity.
lda    is the leading dimension of the two dimensional array containing A.
When side = 'L' or 'l' then lda must be at least max(1, m), when
side = 'R' or 'r' then lda must be at least max(1, n).
B      is a double precision array of dimensions (ldb, n). ldb must be
at least max (1,m). The leading m x n part of the array B must
contain the right-hand side matrix B. On exit B is overwritten
by the solution matrix X.
ldb    is the leading dimension of the two dimensional array containing B.
ldb must be at least max(1, m).

Output
------
B      contains the solution matrix X satisfying op(A) * X = alpha * B,
or X * op(A) = alpha * B

Reference: http://www.netlib.org/blas/dtrsm.f

Error status for this function can be retrieved via cublasGetError().

Error Status
------------
CUBLAS_STATUS_NOT_INITIALIZED  if CUBLAS library has not been initialized
CUBLAS_STATUS_INVALID_VALUE    if m or n < 0
CUBLAS_STATUS_ARCH_MISMATCH    if invoked on device without DP support
CUBLAS_STATUS_EXECUTION_FAILED if function failed to launch on GPU
</pre>