# stdlib_linalg_blas_z Module

## Functions

### public pure function stdlib_zdotc(n, zx, incx, zy, incy)

ZDOTC forms the dot product of two complex vectors ZDOTC = X^H * Y

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: zy(*)
integer(kind=ilp), intent(in) :: incy

### public pure function stdlib_zdotu(n, zx, incx, zy, incy)

ZDOTU forms the dot product of two complex vectors ZDOTU = X^T * Y

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: zy(*)
integer(kind=ilp), intent(in) :: incy

## Subroutines

### public pure subroutine stdlib_zaxpy(n, za, zx, incx, zy, incy)

ZAXPY constant times a vector plus a vector.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: za
complex(kind=dp), intent(in) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(inout) :: zy(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zcopy(n, zx, incx, zy, incy)

ZCOPY copies a vector, x, to a vector, y.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(out) :: zy(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zdrot(n, zx, incx, zy, incy, c, s)

Applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(inout) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(inout) :: zy(*)
integer(kind=ilp), intent(in) :: incy
real(kind=dp), intent(in) :: c
real(kind=dp), intent(in) :: s

### public pure subroutine stdlib_zdscal(n, da, zx, incx)

ZDSCAL scales a vector by a constant.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
real(kind=dp), intent(in) :: da
complex(kind=dp), intent(inout) :: zx(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_zgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)

ZGBMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + betay, or y := alpha*AHx + betay, where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: kl
integer(kind=ilp), intent(in) :: ku
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: y(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

ZGEMM performs one of the matrix-matrix operations C := alphaop( A )op( B ) + betaC, where op( X ) is one of op( X ) = X or op( X ) = XT or op( X ) = X*H, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: transa
character(len=1), intent(in) :: transb
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

ZGEMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + betay, or y := alpha*AHx + betay, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: y(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zgerc(m, n, alpha, x, incx, y, incy, a, lda)

ZGERC performs the rank 1 operation A := alphaxy**H + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: y(*)
integer(kind=ilp), intent(in) :: incy
complex(kind=dp), intent(inout) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda

### public pure subroutine stdlib_zgeru(m, n, alpha, x, incx, y, incy, a, lda)

ZGERU performs the rank 1 operation A := alphaxy**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: y(*)
integer(kind=ilp), intent(in) :: incy
complex(kind=dp), intent(inout) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda

### public pure subroutine stdlib_zhbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)

ZHBMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian band matrix, with k super-diagonals.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: y(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zhemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)

ZHEMM performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is an hermitian matrix and B and C are m by n matrices.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: side
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

ZHEMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: y(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zher(uplo, n, alpha, x, incx, a, lda)

ZHER performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
real(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(inout) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda

### public pure subroutine stdlib_zher2(uplo, n, alpha, x, incx, y, incy, a, lda)

ZHER2 performs the hermitian rank 2 operation A := alphaxyH + conjg( alpha )yxH + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: y(*)
integer(kind=ilp), intent(in) :: incy
complex(kind=dp), intent(inout) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda

### public pure subroutine stdlib_zher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

ZHER2K performs one of the hermitian rank 2k operations C := alphaABH + conjg( alpha )BAH + betaC, or C := alphaAHB + conjg( alpha )BHA + betaC, where alpha and beta are scalars with beta real, C is an n by n hermitian matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb
real(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)

ZHERK performs one of the hermitian rank k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n by n hermitian matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
real(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
real(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zhpmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

ZHPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: ap(*)
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: y(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zhpr(uplo, n, alpha, x, incx, ap)

ZHPR performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix, supplied in packed form.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
real(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(inout) :: ap(*)

### public pure subroutine stdlib_zhpr2(uplo, n, alpha, x, incx, y, incy, ap)

ZHPR2 performs the hermitian rank 2 operation A := alphaxyH + conjg( alpha )yxH + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: x(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(in) :: y(*)
integer(kind=ilp), intent(in) :: incy
complex(kind=dp), intent(inout) :: ap(*)

### public pure subroutine stdlib_zrotg(a, b, c, s)

The computation uses the formulas |x| = sqrt( Re(x)2 + Im(x)2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|2 + |b|2) s = sgn(a) * conjg(b) / sqrt(|a|2 + |b|2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)sqrt(|a|2 + |b|*2) c = a / r s = b / r the same as in DROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by DROTG if the signs of a and b are not the same.

#### Arguments

Type IntentOptional Attributes Name
complex(kind=dp), intent(inout) :: a
complex(kind=dp), intent(in) :: b
real(kind=dp), intent(out) :: c
complex(kind=dp), intent(out) :: s

### public pure subroutine stdlib_zscal(n, za, zx, incx)

ZSCAL scales a vector by a constant.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: za
complex(kind=dp), intent(inout) :: zx(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_zswap(n, zx, incx, zy, incy)

ZSWAP interchanges two vectors.

#### Arguments

Type IntentOptional Attributes Name
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(inout) :: zx(*)
integer(kind=ilp), intent(in) :: incx
complex(kind=dp), intent(inout) :: zy(*)
integer(kind=ilp), intent(in) :: incy

### public pure subroutine stdlib_zsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)

ZSYMM performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: side
character(len=1), intent(in) :: uplo
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

ZSYR2K performs one of the symmetric rank 2k operations C := alphaABT + alphaBAT + betaC, or C := alphaATB + alphaBTA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_zsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)

ZSYRK performs one of the symmetric rank k operations C := alphaAAT + betaC, or C := alphaATA + betaC, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(in) :: beta
complex(kind=dp), intent(inout) :: c(ldc,*)
integer(kind=ilp), intent(in) :: ldc

### public pure subroutine stdlib_ztbmv(uplo, trans, diag, n, k, a, lda, x, incx)

ZTBMV performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_ztbsv(uplo, trans, diag, n, k, a, lda, x, incx)

ZTBSV solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
integer(kind=ilp), intent(in) :: k
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_ztpmv(uplo, trans, diag, n, ap, x, incx)

ZTPMV performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: ap(*)
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_ztpsv(uplo, trans, diag, n, ap, x, incx)

ZTPSV solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: ap(*)
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_ztrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)

ZTRMM performs one of the matrix-matrix operations B := alphaop( A )B, or B := alphaBop( A ) where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = AT or op( A ) = AH.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: side
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: transa
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb

### public pure subroutine stdlib_ztrmv(uplo, trans, diag, n, a, lda, x, incx)

ZTRMV performs one of the matrix-vector operations x := Ax, or x := ATx, or x := A*Hx, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx

### public pure subroutine stdlib_ztrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)

ZTRSM solves one of the matrix equations op( A )X = alphaB, or Xop( A ) = alphaB, 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 ) = AT or op( A ) = AH. The matrix X is overwritten on B.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: side
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: transa
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: m
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: alpha
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: b(ldb,*)
integer(kind=ilp), intent(in) :: ldb

### public pure subroutine stdlib_ztrsv(uplo, trans, diag, n, a, lda, x, incx)

ZTRSV solves one of the systems of equations Ax = b, or ATx = b, or A*Hx = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.

#### Arguments

Type IntentOptional Attributes Name
character(len=1), intent(in) :: uplo
character(len=1), intent(in) :: trans
character(len=1), intent(in) :: diag
integer(kind=ilp), intent(in) :: n
complex(kind=dp), intent(in) :: a(lda,*)
integer(kind=ilp), intent(in) :: lda
complex(kind=dp), intent(inout) :: x(*)
integer(kind=ilp), intent(in) :: incx