Low-level BLAS functions (scipy.linalg.blas)#

This module contains low-level functions from the BLAS library.

Added in version 0.12.0.

Note

The common overwrite_<> option in many routines, allows the input arrays to be overwritten to avoid extra memory allocation. However this requires the array to satisfy two conditions which are memory order and the data type to match exactly the order and the type expected by the routine.

As an example, if you pass a double precision float array to any S.... routine which expects single precision arguments, f2py will create an intermediate array to match the argument types and overwriting will be performed on that intermediate array.

Similarly, if a C-contiguous array is passed, f2py will pass a FORTRAN-contiguous array internally. Please make sure that these details are satisfied. More information can be found in the f2py documentation.

Warning

These functions do little to no error checking. It is possible to cause crashes by misusing them, so prefer using the higher-level routines in scipy.linalg.

Note

Prefer using get_blas_funcs to importing the bare functions directly. If you do, for example, from scipy.linalg.blas import dgemm, the dgemm function may be either LP64 or ILP64, depending on how SciPy is built.

The following is more robust:

>>> from scipy.linalg.blas import get_blas_funcs
>>> dgemm = get_blas_funcs('gemm', dtype='float64', ilp64='preferred')
>>> dgemm.int_dtype
dtype('int32')    # may vary

Finding functions#

get_blas_funcs(names[, arrays, dtype, ilp64])

Return available BLAS function objects from names.

find_best_blas_type([arrays, dtype])

Find best-matching BLAS/LAPACK type.

BLAS Level 1 functions#

sasum(x[, n, offx, incx])

Compute the sum of absolute values sum(abs(x)) (BLAS sasum).

saxpy(x, y[, n, a, offx, incx, offy, incy])

Compute y = a*x + y (BLAS saxpy).

scasum(x[, n, offx, incx])

Compute sum(abs(x.real) + abs(x.imag)) (BLAS scasum).

scnrm2(x[, n, offx, incx])

Compute the Euclidean norm sqrt(sum(abs(x)**2)) (BLAS scnrm2).

scopy(x, y[, n, offx, incx, offy, incy])

Copy x into y (BLAS scopy).

sdot(x, y[, n, offx, incx, offy, incy])

Compute the dot product sum(x*y) (BLAS sdot).

snrm2(x[, n, offx, incx])

Compute the Euclidean norm sqrt(sum(abs(x)**2)) (BLAS snrm2).

srot(x, y, c, s[, n, offx, incx, offy, ...])

Apply a Givens plane rotation to x and y: x, y = c*x + s*y, c*y - s*x (BLAS srot).

srotg(a, b)

Construct a Givens plane rotation (c, s) that eliminates b (BLAS srotg).

srotm(x, y, param[, n, offx, incx, offy, ...])

Apply a modified Givens rotation to x and y (BLAS srotm).

srotmg(d1, d2, x1, y1)

Construct a modified Givens rotation (BLAS srotmg).

sscal(a, x[, n, offx, incx])

Scale x in place by a: x = a*x (BLAS sscal).

sswap(x, y[, n, offx, incx, offy, incy])

Swap the contents of x and y in place (BLAS sswap).

dasum(x[, n, offx, incx])

Compute the sum of absolute values sum(abs(x)) (BLAS dasum).

daxpy(x, y[, n, a, offx, incx, offy, incy])

Compute y = a*x + y (BLAS daxpy).

dcopy(x, y[, n, offx, incx, offy, incy])

Copy x into y (BLAS dcopy).

ddot(x, y[, n, offx, incx, offy, incy])

Compute the dot product sum(x*y) (BLAS ddot).

dnrm2(x[, n, offx, incx])

Compute the Euclidean norm sqrt(sum(abs(x)**2)) (BLAS dnrm2).

drot(x, y, c, s[, n, offx, incx, offy, ...])

Apply a Givens plane rotation to x and y: x, y = c*x + s*y, c*y - s*x (BLAS drot).

drotg(a, b)

Construct a Givens plane rotation (c, s) that eliminates b (BLAS drotg).

drotm(x, y, param[, n, offx, incx, offy, ...])

Apply a modified Givens rotation to x and y (BLAS drotm).

drotmg(d1, d2, x1, y1)

Construct a modified Givens rotation (BLAS drotmg).

dscal(a, x[, n, offx, incx])

Scale x in place by a: x = a*x (BLAS dscal).

dswap(x, y[, n, offx, incx, offy, incy])

Swap the contents of x and y in place (BLAS dswap).

dzasum(x[, n, offx, incx])

Compute sum(abs(x.real) + abs(x.imag)) (BLAS dzasum).

dznrm2(x[, n, offx, incx])

Compute the Euclidean norm sqrt(sum(abs(x)**2)) (BLAS dznrm2).

icamax(x[, n, offx, incx])

Return the index of the element of x with the largest absolute value (BLAS icamax).

idamax(x[, n, offx, incx])

Return the index of the element of x with the largest absolute value (BLAS idamax).

isamax(x[, n, offx, incx])

Return the index of the element of x with the largest absolute value (BLAS isamax).

izamax(x[, n, offx, incx])

Return the index of the element of x with the largest absolute value (BLAS izamax).

caxpy(x, y[, n, a, offx, incx, offy, incy])

Compute y = a*x + y (BLAS caxpy).

ccopy(x, y[, n, offx, incx, offy, incy])

Copy x into y (BLAS ccopy).

cdotc(x, y[, n, offx, incx, offy, incy])

Compute the dot product with x conjugated: sum(conj(x)*y) (BLAS cdotc).

cdotu(x, y[, n, offx, incx, offy, incy])

Compute the unconjugated dot product sum(x*y) (BLAS cdotu).

crotg(a, b)

Construct a Givens plane rotation (c, s) that eliminates b (BLAS crotg).

cscal(a, x[, n, offx, incx])

Scale x in place by a: x = a*x (BLAS cscal).

csrot(x, y, c, s[, n, offx, incx, offy, ...])

Apply a Givens plane rotation to x and y: x, y = c*x + s*y, c*y - s*x (BLAS csrot).

csscal(a, x[, n, offx, incx, overwrite_x])

Scale complex x by the real scalar a: x = a*x (BLAS csscal).

cswap(x, y[, n, offx, incx, offy, incy])

Swap the contents of x and y in place (BLAS cswap).

zaxpy(x, y[, n, a, offx, incx, offy, incy])

Compute y = a*x + y (BLAS zaxpy).

zcopy(x, y[, n, offx, incx, offy, incy])

Copy x into y (BLAS zcopy).

zdotc(x, y[, n, offx, incx, offy, incy])

Compute the dot product with x conjugated: sum(conj(x)*y) (BLAS zdotc).

zdotu(x, y[, n, offx, incx, offy, incy])

Compute the unconjugated dot product sum(x*y) (BLAS zdotu).

zdrot(x, y, c, s[, n, offx, incx, offy, ...])

Apply a Givens plane rotation to x and y: x, y = c*x + s*y, c*y - s*x (BLAS zdrot).

zdscal(a, x[, n, offx, incx, overwrite_x])

Scale complex x by the real scalar a: x = a*x (BLAS zdscal).

zrotg(a, b)

Construct a Givens plane rotation (c, s) that eliminates b (BLAS zrotg).

zscal(a, x[, n, offx, incx])

Scale x in place by a: x = a*x (BLAS zscal).

zswap(x, y[, n, offx, incx, offy, incy])

Swap the contents of x and y in place (BLAS zswap).

BLAS Level 2 functions#

sgbmv(m, n, kl, ku, alpha, a, x[, incx, ...])

Compute y = alpha*op(a)@x + beta*y for a banded matrix a (BLAS sgbmv).

sgemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute the matrix-vector product y = alpha*op(a)@x + beta*y (BLAS sgemv).

sger(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, y) + a (BLAS sger).

ssbmv(k, alpha, a, x[, incx, offx, beta, y, ...])

Compute y = alpha*a@x + beta*y for a banded symmetric matrix a (BLAS ssbmv).

sspmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed symmetric matrix (BLAS sspmv).

sspr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed symmetric rank-1 update ap = alpha*outer(x, x) + ap (BLAS sspr).

sspr2(n, alpha, x, y, ap[, incx, offx, ...])

Packed symmetric rank-2 update ap = alpha*(outer(x, y) + outer(y, x)) + ap (BLAS sspr2).

ssymv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a symmetric matrix a (BLAS ssymv).

ssyr(alpha, x[, lower, incx, offx, n, a, ...])

Symmetric rank-1 update a = alpha*outer(x, x) + a (BLAS ssyr).

ssyr2(alpha, x, y[, lower, incx, offx, ...])

Symmetric rank-2 update a = alpha*(outer(x, y) + outer(y, x)) + a (BLAS ssyr2).

stbmv(k, a, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a banded triangular matrix (BLAS stbmv).

stbsv(k, a, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a banded triangular matrix (BLAS stbsv).

stpmv(n, ap, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a packed triangular matrix (BLAS stpmv).

stpsv(n, ap, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a packed triangular matrix (BLAS stpsv).

strmv(a, x[, offx, incx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x (BLAS strmv).

strsv(a, x[, offx, incx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place (BLAS strsv).

dgbmv(m, n, kl, ku, alpha, a, x[, incx, ...])

Compute y = alpha*op(a)@x + beta*y for a banded matrix a (BLAS dgbmv).

dgemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute the matrix-vector product y = alpha*op(a)@x + beta*y (BLAS dgemv).

dger(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, y) + a (BLAS dger).

dsbmv(k, alpha, a, x[, incx, offx, beta, y, ...])

Compute y = alpha*a@x + beta*y for a banded symmetric matrix a (BLAS dsbmv).

dspmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed symmetric matrix (BLAS dspmv).

dspr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed symmetric rank-1 update ap = alpha*outer(x, x) + ap (BLAS dspr).

dspr2(n, alpha, x, y, ap[, incx, offx, ...])

Packed symmetric rank-2 update ap = alpha*(outer(x, y) + outer(y, x)) + ap (BLAS dspr2).

dsymv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a symmetric matrix a (BLAS dsymv).

dsyr(alpha, x[, lower, incx, offx, n, a, ...])

Symmetric rank-1 update a = alpha*outer(x, x) + a (BLAS dsyr).

dsyr2(alpha, x, y[, lower, incx, offx, ...])

Symmetric rank-2 update a = alpha*(outer(x, y) + outer(y, x)) + a (BLAS dsyr2).

dtbmv(k, a, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a banded triangular matrix (BLAS dtbmv).

dtbsv(k, a, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a banded triangular matrix (BLAS dtbsv).

dtpmv(n, ap, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a packed triangular matrix (BLAS dtpmv).

dtpsv(n, ap, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a packed triangular matrix (BLAS dtpsv).

dtrmv(a, x[, offx, incx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x (BLAS dtrmv).

dtrsv(a, x[, offx, incx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place (BLAS dtrsv).

cgbmv(m, n, kl, ku, alpha, a, x[, incx, ...])

Compute y = alpha*op(a)@x + beta*y for a banded matrix a (BLAS cgbmv).

cgemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute the matrix-vector product y = alpha*op(a)@x + beta*y (BLAS cgemv).

cgerc(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, conj(y)) + a (BLAS cgerc).

cgeru(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, y) + a (BLAS cgeru).

chbmv(k, alpha, a, x[, incx, offx, beta, y, ...])

Compute y = alpha*a@x + beta*y for a banded Hermitian matrix a (BLAS chbmv).

chemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a Hermitian matrix a (BLAS chemv).

cher(alpha, x[, lower, incx, offx, n, a, ...])

Hermitian rank-1 update a = alpha*outer(x, conj(x)) + a (BLAS cher).

cher2(alpha, x, y[, lower, incx, offx, ...])

Hermitian rank-2 update a = alpha*outer(x, conj(y)) + conj(alpha)*outer(y, conj(x)) + a (BLAS cher2).

chpmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed Hermitian matrix (BLAS chpmv).

chpr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed Hermitian rank-1 update ap = alpha*outer(x, conj(x)) + ap (BLAS chpr).

chpr2(n, alpha, x, y, ap[, incx, offx, ...])

Packed Hermitian rank-2 update ap = alpha*outer(x, conj(y)) + conj(alpha)*outer(y, conj(x)) + ap (BLAS chpr2).

cspmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed symmetric matrix (BLAS cspmv).

cspr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed symmetric rank-1 update ap = alpha*outer(x, x) + ap (BLAS cspr).

csymv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a symmetric matrix a (BLAS csymv).

csyr(alpha, x[, lower, incx, offx, n, a, ...])

Symmetric rank-1 update a = alpha*outer(x, x) + a (BLAS csyr).

ctbmv(k, a, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a banded triangular matrix (BLAS ctbmv).

ctbsv(k, a, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a banded triangular matrix (BLAS ctbsv).

ctpmv(n, ap, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a packed triangular matrix (BLAS ctpmv).

ctpsv(n, ap, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a packed triangular matrix (BLAS ctpsv).

ctrmv(a, x[, offx, incx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x (BLAS ctrmv).

ctrsv(a, x[, offx, incx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place (BLAS ctrsv).

zgbmv(m, n, kl, ku, alpha, a, x[, incx, ...])

Compute y = alpha*op(a)@x + beta*y for a banded matrix a (BLAS zgbmv).

zgemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute the matrix-vector product y = alpha*op(a)@x + beta*y (BLAS zgemv).

zgerc(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, conj(y)) + a (BLAS zgerc).

zgeru(alpha, x, y[, incx, incy, a, ...])

General rank-1 update a = alpha*outer(x, y) + a (BLAS zgeru).

zhbmv(k, alpha, a, x[, incx, offx, beta, y, ...])

Compute y = alpha*a@x + beta*y for a banded Hermitian matrix a (BLAS zhbmv).

zhemv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a Hermitian matrix a (BLAS zhemv).

zher(alpha, x[, lower, incx, offx, n, a, ...])

Hermitian rank-1 update a = alpha*outer(x, conj(x)) + a (BLAS zher).

zher2(alpha, x, y[, lower, incx, offx, ...])

Hermitian rank-2 update a = alpha*outer(x, conj(y)) + conj(alpha)*outer(y, conj(x)) + a (BLAS zher2).

zhpmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed Hermitian matrix (BLAS zhpmv).

zhpr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed Hermitian rank-1 update ap = alpha*outer(x, conj(x)) + ap (BLAS zhpr).

zhpr2(n, alpha, x, y, ap[, incx, offx, ...])

Packed Hermitian rank-2 update ap = alpha*outer(x, conj(y)) + conj(alpha)*outer(y, conj(x)) + ap (BLAS zhpr2).

zspmv(n, alpha, ap, x[, incx, offx, beta, ...])

Compute y = alpha*a@x + beta*y for a packed symmetric matrix (BLAS zspmv).

zspr(n, alpha, x, ap[, incx, offx, lower, ...])

Packed symmetric rank-1 update ap = alpha*outer(x, x) + ap (BLAS zspr).

zsymv(alpha, a, x[, beta, y, offx, incx, ...])

Compute y = alpha*a@x + beta*y for a symmetric matrix a (BLAS zsymv).

zsyr(alpha, x[, lower, incx, offx, n, a, ...])

Symmetric rank-1 update a = alpha*outer(x, x) + a (BLAS zsyr).

ztbmv(k, a, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a banded triangular matrix (BLAS ztbmv).

ztbsv(k, a, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a banded triangular matrix (BLAS ztbsv).

ztpmv(n, ap, x[, incx, offx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x for a packed triangular matrix (BLAS ztpmv).

ztpsv(n, ap, x[, incx, offx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place for a packed triangular matrix (BLAS ztpsv).

ztrmv(a, x[, offx, incx, lower, trans, ...])

Compute the triangular matrix-vector product x = op(a)@x (BLAS ztrmv).

ztrsv(a, x[, offx, incx, lower, trans, ...])

Solve the triangular system op(a)@x = b in place (BLAS ztrsv).

BLAS Level 3 functions#

sgemm(alpha, a, b[, beta, c, trans_a, ...])

Compute the matrix-matrix product c = alpha*op(a)@op(b) + beta*c (BLAS sgemm).

ssymm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a symmetric matrix a (BLAS ssymm).

ssyr2k(alpha, a, b[, beta, c, trans, lower, ...])

Symmetric rank-2k update c = alpha*(op(a)@op(b).T + op(b)@op(a).T) + beta*c (BLAS ssyr2k).

ssyrk(alpha, a[, beta, c, trans, lower, ...])

Symmetric rank-k update c = alpha*op(a)@op(a).T + beta*c (BLAS ssyrk).

strmm(alpha, a, b[, side, lower, trans_a, ...])

Compute the triangular matrix-matrix product b = alpha*op(a)@b (BLAS strmm).

strsm(alpha, a, b[, side, lower, trans_a, ...])

Solve the triangular system op(a)@x = alpha*b for x (BLAS strsm).

dgemm(alpha, a, b[, beta, c, trans_a, ...])

Compute the matrix-matrix product c = alpha*op(a)@op(b) + beta*c (BLAS dgemm).

dsymm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a symmetric matrix a (BLAS dsymm).

dsyr2k(alpha, a, b[, beta, c, trans, lower, ...])

Symmetric rank-2k update c = alpha*(op(a)@op(b).T + op(b)@op(a).T) + beta*c (BLAS dsyr2k).

dsyrk(alpha, a[, beta, c, trans, lower, ...])

Symmetric rank-k update c = alpha*op(a)@op(a).T + beta*c (BLAS dsyrk).

dtrmm(alpha, a, b[, side, lower, trans_a, ...])

Compute the triangular matrix-matrix product b = alpha*op(a)@b (BLAS dtrmm).

dtrsm(alpha, a, b[, side, lower, trans_a, ...])

Solve the triangular system op(a)@x = alpha*b for x (BLAS dtrsm).

cgemm(alpha, a, b[, beta, c, trans_a, ...])

Compute the matrix-matrix product c = alpha*op(a)@op(b) + beta*c (BLAS cgemm).

chemm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a Hermitian matrix a (BLAS chemm).

cher2k(alpha, a, b[, beta, c, trans, lower, ...])

Hermitian rank-2k update c = alpha*op(a)@op(b).conj().T + conj(alpha)*op(b)@op(a).conj().T + beta*c (BLAS cher2k).

cherk(alpha, a[, beta, c, trans, lower, ...])

Hermitian rank-k update c = alpha*op(a)@op(a).conj().T + beta*c (BLAS cherk).

csymm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a symmetric matrix a (BLAS csymm).

csyr2k(alpha, a, b[, beta, c, trans, lower, ...])

Symmetric rank-2k update c = alpha*(op(a)@op(b).T + op(b)@op(a).T) + beta*c (BLAS csyr2k).

csyrk(alpha, a[, beta, c, trans, lower, ...])

Symmetric rank-k update c = alpha*op(a)@op(a).T + beta*c (BLAS csyrk).

ctrmm(alpha, a, b[, side, lower, trans_a, ...])

Compute the triangular matrix-matrix product b = alpha*op(a)@b (BLAS ctrmm).

ctrsm(alpha, a, b[, side, lower, trans_a, ...])

Solve the triangular system op(a)@x = alpha*b for x (BLAS ctrsm).

zgemm(alpha, a, b[, beta, c, trans_a, ...])

Compute the matrix-matrix product c = alpha*op(a)@op(b) + beta*c (BLAS zgemm).

zhemm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a Hermitian matrix a (BLAS zhemm).

zher2k(alpha, a, b[, beta, c, trans, lower, ...])

Hermitian rank-2k update c = alpha*op(a)@op(b).conj().T + conj(alpha)*op(b)@op(a).conj().T + beta*c (BLAS zher2k).

zherk(alpha, a[, beta, c, trans, lower, ...])

Hermitian rank-k update c = alpha*op(a)@op(a).conj().T + beta*c (BLAS zherk).

zsymm(alpha, a, b[, beta, c, side, lower, ...])

Compute c = alpha*a@b + beta*c for a symmetric matrix a (BLAS zsymm).

zsyr2k(alpha, a, b[, beta, c, trans, lower, ...])

Symmetric rank-2k update c = alpha*(op(a)@op(b).T + op(b)@op(a).T) + beta*c (BLAS zsyr2k).

zsyrk(alpha, a[, beta, c, trans, lower, ...])

Symmetric rank-k update c = alpha*op(a)@op(a).T + beta*c (BLAS zsyrk).

ztrmm(alpha, a, b[, side, lower, trans_a, ...])

Compute the triangular matrix-matrix product b = alpha*op(a)@b (BLAS ztrmm).

ztrsm(alpha, a, b[, side, lower, trans_a, ...])

Solve the triangular system op(a)@x = alpha*b for x (BLAS ztrsm).