stdlib_linalg_blas – Fortran-lang/stdlib

public interface axpy

AXPY constant times a vector plus a vector.

public pure subroutine caxpy(n, ca, cx, incx, cy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	ca
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine daxpy(n, da, dx, incx, dy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	da
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine saxpy(n, sa, sx, incx, sy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

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

Arguments

Type	Intent		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_caxpy(n, ca, cx, incx, cy, incy)

CAXPY constant times a vector plus a vector.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	ca
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_daxpy(n, da, dx, incx, dy, incy)

DAXPY constant times a vector plus a vector. uses unrolled loops for increments equal to one.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	da
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_saxpy(n, sa, sx, incx, sy, incy)

SAXPY constant times a vector plus a vector. uses unrolled loops for increments equal to one.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

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

ZAXPY constant times a vector plus a vector.

Arguments

Type	Intent		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 interface copy

COPY copies a vector x to a vector y.

public pure subroutine ccopy(n, cx, incx, cy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(out)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine dcopy(n, dx, incx, dy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(out)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine scopy(n, sx, incx, sy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(out)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine zcopy(n, zx, incx, zy, incy)

Arguments

Type	Intent		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_ccopy(n, cx, incx, cy, incy)

CCOPY copies a vector x to a vector y.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(out)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_dcopy(n, dx, incx, dy, incy)

DCOPY copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(out)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_scopy(n, sx, incx, sy, incy)

SCOPY copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(out)	::	sy(*)
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	Intent		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 interface dot

DOT forms the dot product of two vectors. uses unrolled loops for increments equal to one.

public pure function ddot(n, dx, incx, dy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(in)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=dp)

public pure function sdot(n, sx, incx, sy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=sp)

public pure function stdlib_ddot(n, dx, incx, dy, incy)

DDOT forms the dot product of two vectors. uses unrolled loops for increments equal to one.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(in)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=dp)

public pure function stdlib_sdot(n, sx, incx, sy, incy)

SDOT forms the dot product of two vectors. uses unrolled loops for increments equal to one.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=sp)

public interface dotc

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

public pure function cdotc(n, cx, incx, cy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value complex(kind=sp)

public pure function zdotc(n, zx, incx, zy, incy)

Arguments

Type	Intent		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

Return Value complex(kind=dp)

public pure function stdlib_cdotc(n, cx, incx, cy, incy)

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

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value complex(kind=sp)

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	Intent		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

Return Value complex(kind=dp)

public interface dotu

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

public pure function cdotu(n, cx, incx, cy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value complex(kind=sp)

public pure function zdotu(n, zx, incx, zy, incy)

Arguments

Type	Intent		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

Return Value complex(kind=dp)

public pure function stdlib_cdotu(n, cx, incx, cy, incy)

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

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value complex(kind=sp)

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	Intent		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

Return Value complex(kind=dp)

public interface gbmv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

Arguments

Type	Intent		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_cgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)

CGBMV 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

DGBMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + 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	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

SGBMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + 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	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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	Intent		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 interface gemm

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

CGEMM 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

DGEMM 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 ) = X*T, 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	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

SGEMM 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 ) = X*T, 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	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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	Intent		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 interface gemv

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

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

Arguments

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

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

Arguments

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

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

Arguments

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

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

Arguments

Type	Intent		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_cgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy)

CGEMV 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	Intent		Name
character(len=1),	intent(in)	::	trans
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

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

Arguments

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

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

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

Arguments

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

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	Intent		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 interface ger

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

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

Arguments

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

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

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

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

DGER 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	Intent		Name
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=dp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

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

SGER 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	Intent		Name
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

public interface gerc

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

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

Arguments

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

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

Arguments

Type	Intent		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_cgerc(m, n, alpha, x, incx, y, incy, a, lda)

CGERC 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	Intent		Name
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
complex(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

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	Intent		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 interface geru

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

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

Arguments

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

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

Arguments

Type	Intent		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_cgeru(m, n, alpha, x, incx, y, incy, a, lda)

CGERU 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	Intent		Name
integer(kind=ilp),	intent(in)	::	m
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
complex(kind=sp),	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	Intent		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 interface hbmv

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

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

Arguments

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

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

Arguments

Type	Intent		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_chbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)

CHBMV 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
integer(kind=ilp),	intent(in)	::	k
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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	Intent		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 interface hemm

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_chemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)

CHEMM 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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	Intent		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 interface hemv

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

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

Arguments

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

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

Arguments

Type	Intent		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_chemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy)

CHEMV 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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	Intent		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 interface her

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

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

Arguments

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

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

Arguments

Type	Intent		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_cher(uplo, n, alpha, x, incx, a, lda)

CHER 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

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	Intent		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 interface her2

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

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

Arguments

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

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

Arguments

Type	Intent		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_cher2(uplo, n, alpha, x, incx, y, incy, a, lda)

CHER2 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
complex(kind=sp),	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	Intent		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 interface her2k

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_cher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

CHER2K 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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	Intent		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 interface herk

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_cherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)

CHERK 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	beta
complex(kind=sp),	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	Intent		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 interface hpmv

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

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

Arguments

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

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

Arguments

Type	Intent		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_chpmv(uplo, n, alpha, ap, x, incx, beta, y, incy)

CHPMV 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	ap(*)
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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	Intent		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 interface hpr

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

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

Arguments

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

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

Arguments

Type	Intent		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_chpr(uplo, n, alpha, x, incx, ap)

CHPR 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	ap(*)

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	Intent		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 interface hpr2

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

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

Arguments

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

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

Arguments

Type	Intent		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_chpr2(uplo, n, alpha, x, incx, y, incy, ap)

CHPR2 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	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
complex(kind=sp),	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	Intent		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 interface nrm2

NRM2 returns the euclidean norm of a vector via the function name, so that NRM2 := sqrt( x'*x )

public pure function dnrm2(n, x, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

Return Value real(kind=dp)

public pure function snrm2(n, x, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

Return Value real(kind=sp)

public pure function stdlib_dnrm2(n, x, incx)

DNRM2 returns the euclidean norm of a vector via the function name, so that DNRM2 := sqrt( x'*x )

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

Return Value real(kind=dp)

public pure function stdlib_snrm2(n, x, incx)

SNRM2 returns the euclidean norm of a vector via the function name, so that SNRM2 := sqrt( x'*x ).

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

Return Value real(kind=sp)

public interface rot

ROT applies a plane rotation.

public pure subroutine drot(n, dx, incx, dy, incy, c, s)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=dp),	intent(in)	::	c
real(kind=dp),	intent(in)	::	s

public pure subroutine srot(n, sx, incx, sy, incy, c, s)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	c
real(kind=sp),	intent(in)	::	s

public pure subroutine stdlib_drot(n, dx, incx, dy, incy, c, s)

DROT applies a plane rotation.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=dp),	intent(in)	::	c
real(kind=dp),	intent(in)	::	s

public pure subroutine stdlib_srot(n, sx, incx, sy, incy, c, s)

applies a plane rotation.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	c
real(kind=sp),	intent(in)	::	s

public interface rotg

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 SROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by SROTG if the signs of a and b are not the same.

public pure subroutine crotg(a, b, c, s)

Arguments

Type	Intent		Name
complex(kind=sp),	intent(inout)	::	a
complex(kind=sp),	intent(in)	::	b
real(kind=sp),	intent(out)	::	c
complex(kind=sp),	intent(out)	::	s

public pure subroutine drotg(a, b, c, s)

Arguments

Type	Intent		Name
real(kind=dp),	intent(inout)	::	a
real(kind=dp),	intent(inout)	::	b
real(kind=dp),	intent(out)	::	c
real(kind=dp),	intent(out)	::	s

public pure subroutine srotg(a, b, c, s)

Arguments

Type	Intent		Name
real(kind=sp),	intent(inout)	::	a
real(kind=sp),	intent(inout)	::	b
real(kind=sp),	intent(out)	::	c
real(kind=sp),	intent(out)	::	s

public pure subroutine zrotg(a, b, c, s)

Arguments

Type	Intent		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_crotg(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 SROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by SROTG if the signs of a and b are not the same.

Arguments

Type	Intent		Name
complex(kind=sp),	intent(inout)	::	a
complex(kind=sp),	intent(in)	::	b
real(kind=sp),	intent(out)	::	c
complex(kind=sp),	intent(out)	::	s

public pure subroutine stdlib_drotg(a, b, c, s)

The computation uses the formulas sigma = sgn(a) if |a| > |b| = sgn(b) if |b| >= |a| r = sigmasqrt( a2 + b2 ) c = 1; s = 0 if r = 0 c = a/r; s = b/r if r != 0 The subroutine also computes z = s if |a| > |b|, = 1/c if |b| >= |a| and c != 0 = 1 if c = 0 This allows c and s to be reconstructed from z as follows: If z = 1, set c = 0, s = 1. If |z| < 1, set c = sqrt(1 - z2) and s = z. If |z| > 1, set c = 1/z and s = sqrt( 1 - c*2).

Arguments

Type	Intent		Name
real(kind=dp),	intent(inout)	::	a
real(kind=dp),	intent(inout)	::	b
real(kind=dp),	intent(out)	::	c
real(kind=dp),	intent(out)	::	s

public pure subroutine stdlib_srotg(a, b, c, s)

The computation uses the formulas sigma = sgn(a) if |a| > |b| = sgn(b) if |b| >= |a| r = sigmasqrt( a2 + b2 ) c = 1; s = 0 if r = 0 c = a/r; s = b/r if r != 0 The subroutine also computes z = s if |a| > |b|, = 1/c if |b| >= |a| and c != 0 = 1 if c = 0 This allows c and s to be reconstructed from z as follows: If z = 1, set c = 0, s = 1. If |z| < 1, set c = sqrt(1 - z2) and s = z. If |z| > 1, set c = 1/z and s = sqrt( 1 - c*2).

Arguments

Type	Intent		Name
real(kind=sp),	intent(inout)	::	a
real(kind=sp),	intent(inout)	::	b
real(kind=sp),	intent(out)	::	c
real(kind=sp),	intent(out)	::	s

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	Intent		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 interface rotm

ROTM applies the modified Givens transformation, $H$ , to the 2-by-N matrix $\left[ \begin{array}{c}DX^T\\DY^T\\ \end{array} \right],$ where $^T$ indicates transpose. The elements of $DX$ are in DX(LX+IINCX), I = 0:N-1, where LX = 1 if INCX >= 0, else LX = (-INCX)N, and similarly for DY using LY and INCY. With DPARAM(1)=DFLAG, $H$ has one of the following forms: $H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$
See ROTMG for a description of data storage in DPARAM.

public pure subroutine drotm(n, dx, incx, dy, incy, dparam)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=dp),	intent(in)	::	dparam(5)

public pure subroutine srotm(n, sx, incx, sy, incy, sparam)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	sparam(5)

public pure subroutine stdlib_drotm(n, dx, incx, dy, incy, dparam)

DROTM applies the modified Givens transformation, $H$ , to the 2-by-N matrix $\left[ \begin{array}{c}DX^T\\DY^T\\ \end{array} \right],$ where $^T$ indicates transpose. The elements of $DX$ are in DX(LX+IINCX), I = 0:N-1, where LX = 1 if INCX >= 0, else LX = (-INCX)N, and similarly for DY using LY and INCY. With DPARAM(1)=DFLAG, $H$ has one of the following forms: $H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$
See DROTMG for a description of data storage in DPARAM.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=dp),	intent(in)	::	dparam(5)

public pure subroutine stdlib_srotm(n, sx, incx, sy, incy, sparam)

SROTM applies the modified Givens transformation, $H$ , to the 2-by-N matrix $\left[ \begin{array}{c}SX^T\\SY^T\\ \end{array} \right],$ where $^T$ indicates transpose. The elements of $SX$ are in SX(LX+IINCX), I = 0:N-1, where LX = 1 if INCX >= 0, else LX = (-INCX)N, and similarly for SY using LY and INCY. With SPARAM(1)=SFLAG, $H$ has one of the following forms: $H=\underbrace{\begin{bmatrix}SH_{11} & SH_{12}\\SH_{21} & SH_{22}\end{bmatrix}}_{SFLAG=-1}, \underbrace{\begin{bmatrix}1 & SH_{12}\\SH_{21} & 1\end{bmatrix}}_{SFLAG=0}, \underbrace{\begin{bmatrix}SH_{11} & 1\\-1 & SH_{22}\end{bmatrix}}_{SFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{SFLAG=-2}.$
See SROTMG for a description of data storage in SPARAM.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	sparam(5)

public interface rotmg

ROTMG Constructs the modified Givens transformation matrix $H$ which zeros the second component of the 2-vector $\left[ {\sqrt{DD_1}\cdot DX_1,\sqrt{DD_2}\cdot DY_2} \right]^T.$ With DPARAM(1)=DFLAG, $H$ has one of the following forms:
$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$ Locations 2-4 of DPARAM contain DH11, DH21, DH12 and DH22 respectively. (Values of 1.0, -1.0, or 0.0 implied by the value of DPARAM(1) are not stored in DPARAM.) The values of parameters GAMSQ and RGAMSQ may be inexact. This is OK as they are only used for testing the size of DD1 and DD2. All actual scaling of data is done using GAM.

public pure subroutine drotmg(dd1, dd2, dx1, dy1, dparam)

Arguments

Type	Intent		Name
real(kind=dp),	intent(inout)	::	dd1
real(kind=dp),	intent(inout)	::	dd2
real(kind=dp),	intent(inout)	::	dx1
real(kind=dp),	intent(in)	::	dy1
real(kind=dp),	intent(out)	::	dparam(5)

public pure subroutine srotmg(sd1, sd2, sx1, sy1, sparam)

Arguments

Type	Intent		Name
real(kind=sp),	intent(inout)	::	sd1
real(kind=sp),	intent(inout)	::	sd2
real(kind=sp),	intent(inout)	::	sx1
real(kind=sp),	intent(in)	::	sy1
real(kind=sp),	intent(out)	::	sparam(5)

public pure subroutine stdlib_drotmg(dd1, dd2, dx1, dy1, dparam)

DROTMG Constructs the modified Givens transformation matrix $H$ which zeros the second component of the 2-vector $\left[ {\sqrt{DD_1}\cdot DX_1,\sqrt{DD_2}\cdot DY_2} \right]^T.$ With DPARAM(1)=DFLAG, $H$ has one of the following forms:
$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$ Locations 2-4 of DPARAM contain DH11, DH21, DH12 and DH22 respectively. (Values of 1.0, -1.0, or 0.0 implied by the value of DPARAM(1) are not stored in DPARAM.) The values of parameters GAMSQ and RGAMSQ may be inexact. This is OK as they are only used for testing the size of DD1 and DD2. All actual scaling of data is done using GAM.

Arguments

Type	Intent		Name
real(kind=dp),	intent(inout)	::	dd1
real(kind=dp),	intent(inout)	::	dd2
real(kind=dp),	intent(inout)	::	dx1
real(kind=dp),	intent(in)	::	dy1
real(kind=dp),	intent(out)	::	dparam(5)

public pure subroutine stdlib_srotmg(sd1, sd2, sx1, sy1, sparam)

SROTMG Constructs the modified Givens transformation matrix $H$ which zeros the second component of the 2-vector $\left[ {\sqrt{SD_1}\cdot SX_1,\sqrt{SD_2}\cdot SY_2} \right]^T.$ With SPARAM(1)=SFLAG, $H$ has one of the following forms:
$H=\underbrace{\begin{bmatrix}SH_{11} & SD_{12}\\SH_{21} & SH_{22}\end{bmatrix}}_{SFLAG=-1}, \underbrace{\begin{bmatrix}1 & SH_{12}\\SH_{21} & 1\end{bmatrix}}_{SFLAG=0}, \underbrace{\begin{bmatrix}SH_{11} & 1\\-1 & SH_{22}\end{bmatrix}}_{SFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{SFLAG=2}.$ Locations 2-4 of SPARAM contain SH11, SH21, SH12 and SH22 respectively. (Values of 1.0, -1.0, or 0.0 implied by the value of SPARAM(1) are not stored in SPARAM.) The values of parameters GAMSQ and RGAMSQ may be inexact. This is OK as they are only used for testing the size of DD1 and DD2. All actual scaling of data is done using GAM.

Arguments

Type	Intent		Name
real(kind=sp),	intent(inout)	::	sd1
real(kind=sp),	intent(inout)	::	sd2
real(kind=sp),	intent(inout)	::	sx1
real(kind=sp),	intent(in)	::	sy1
real(kind=sp),	intent(out)	::	sparam(5)

public interface sbmv

SBMV 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 symmetric band matrix, with k super-diagonals.

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

Arguments

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

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

Arguments

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

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

DSBMV 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 symmetric band matrix, with k super-diagonals.

Arguments

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

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

SSBMV 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 symmetric band matrix, with k super-diagonals.

Arguments

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

public interface scal

SCAL scales a vector by a constant.

public pure subroutine cscal(n, ca, cx, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	ca
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine dscal(n, da, dx, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	da
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine sscal(n, sa, sx, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine zscal(n, za, zx, incx)

Arguments

Type	Intent		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_cscal(n, ca, cx, incx)

CSCAL scales a vector by a constant.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(in)	::	ca
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine stdlib_dscal(n, da, dx, incx)

DSCAL scales a vector by a constant. uses unrolled loops for increment equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(in)	::	da
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine stdlib_sscal(n, sa, sx, incx)

SSCAL scales a vector by a constant. uses unrolled loops for increment equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx

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

ZSCAL scales a vector by a constant.

Arguments

Type	Intent		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 interface sdot

Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY SDOT = sum for I = 0 to N-1 of SX(LX+IINCX) * SY(LY+IINCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX, and LY is defined in a similar way using INCY.

public pure function dsdot(n, sx, incx, sy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=dp)

public pure function stdlib_dsdot(n, sx, incx, sy, incy)

Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY DSDOT = sum for I = 0 to N-1 of SX(LX+IINCX) * SY(LY+IINCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX, and LY is defined in a similar way using INCY.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

Return Value real(kind=dp)

public interface spmv

SPMV 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 symmetric matrix, supplied in packed form.

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

Arguments

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

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

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

DSPMV 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 symmetric matrix, supplied in packed form.

Arguments

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

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

SSPMV 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 symmetric matrix, supplied in packed form.

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

public interface spr

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

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

Arguments

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

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

Arguments

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

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

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

Arguments

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

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

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

Arguments

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

public interface spr2

SPR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

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

Arguments

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

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

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	ap(*)

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

DSPR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

Arguments

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

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

SSPR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	ap(*)

public interface srot

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

public pure subroutine csrot(n, cx, incx, cy, incy, c, s)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	c
real(kind=sp),	intent(in)	::	s

public pure subroutine stdlib_csrot(n, cx, incx, cy, incy, c, s)

CSROT 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	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(in)	::	c
real(kind=sp),	intent(in)	::	s

public interface sscal

SSCAL scales a complex vector by a real constant.

public pure subroutine csscal(n, sa, cx, incx)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx

public pure subroutine stdlib_csscal(n, sa, cx, incx)

CSSCAL scales a complex vector by a real constant.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	sa
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx

public interface swap

SWAP interchanges two vectors.

public pure subroutine cswap(n, cx, incx, cy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine dswap(n, dx, incx, dy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine sswap(n, sx, incx, sy, incy)

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine zswap(n, zx, incx, zy, incy)

Arguments

Type	Intent		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_cswap(n, cx, incx, cy, incy)

CSWAP interchanges two vectors.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
complex(kind=sp),	intent(inout)	::	cx(*)
integer(kind=ilp),	intent(in)	::	incx
complex(kind=sp),	intent(inout)	::	cy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_dswap(n, dx, incx, dy, incy)

DSWAP interchanges two vectors. uses unrolled loops for increments equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=dp),	intent(inout)	::	dx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=dp),	intent(inout)	::	dy(*)
integer(kind=ilp),	intent(in)	::	incy

public pure subroutine stdlib_sswap(n, sx, incx, sy, incy)

SSWAP interchanges two vectors. uses unrolled loops for increments equal to 1.

Arguments

Type	Intent		Name
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(inout)	::	sx(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(inout)	::	sy(*)
integer(kind=ilp),	intent(in)	::	incy

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

ZSWAP interchanges two vectors.

Arguments

Type	Intent		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 interface symm

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_csymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)

CSYMM 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

DSYMM 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	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

SSYMM 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	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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	Intent		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 interface symv

SYMV 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 symmetric matrix.

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

Arguments

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

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

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

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

DSYMV 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 symmetric matrix.

Arguments

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

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

SSYMV 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 symmetric matrix.

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy

public interface syr

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

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

Arguments

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

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

Arguments

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

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

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

Arguments

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

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

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

Arguments

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

public interface syr2

SYR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.

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

Arguments

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

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

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

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

DSYR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.

Arguments

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

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

SSYR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.

Arguments

Type	Intent		Name
character(len=1),	intent(in)	::	uplo
integer(kind=ilp),	intent(in)	::	n
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx
real(kind=sp),	intent(in)	::	y(*)
integer(kind=ilp),	intent(in)	::	incy
real(kind=sp),	intent(inout)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda

public interface syr2k

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_csyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)

CSYR2K 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

DSYR2K 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

SSYR2K 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	Intent		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=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	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	Intent		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 interface syrk

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

Arguments

Type	Intent		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_csyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)

CSYRK 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(in)	::	beta
complex(kind=sp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

DSYRK 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(in)	::	beta
real(kind=dp),	intent(inout)	::	c(ldc,*)
integer(kind=ilp),	intent(in)	::	ldc

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

SSYRK 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	Intent		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=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(in)	::	beta
real(kind=sp),	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	Intent		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 interface tbmv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctbmv(uplo, trans, diag, n, k, a, lda, x, incx)

CTBMV 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	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTBMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STBMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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	Intent		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 interface tbsv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctbsv(uplo, trans, diag, n, k, a, lda, x, incx)

CTBSV 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	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTBSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STBSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	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	Intent		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 interface tpmv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	ap(*)
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	ap(*)
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctpmv(uplo, trans, diag, n, ap, x, incx)

CTPMV 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	Intent		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=sp),	intent(in)	::	ap(*)
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTPMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=dp),	intent(in)	::	ap(*)
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STPMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	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	Intent		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 interface tpsv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	ap(*)
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	ap(*)
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctpsv(uplo, trans, diag, n, ap, x, incx)

CTPSV 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	Intent		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=sp),	intent(in)	::	ap(*)
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTPSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=dp),	intent(in)	::	ap(*)
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STPSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=sp),	intent(in)	::	ap(*)
real(kind=sp),	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	Intent		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 interface trmm

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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_ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)

CTRMM 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

DTRMM 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 ) = A**T.

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

STRMM 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 ) = A**T.

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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	Intent		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 interface trmv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctrmv(uplo, trans, diag, n, a, lda, x, incx)

CTRMV 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	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTRMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STRMV performs one of the matrix-vector operations x := Ax, or x := ATx, 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	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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	Intent		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 interface trsm

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

Arguments

Type	Intent		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_ctrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)

CTRSM 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	Intent		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=sp),	intent(in)	::	alpha
complex(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

DTRSM 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 ) = A**T. The matrix X is overwritten on B.

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	alpha
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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

STRSM 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 ) = A**T. The matrix X is overwritten on B.

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	alpha
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	b(ldb,*)
integer(kind=ilp),	intent(in)	::	ldb

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	Intent		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 interface trsv

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

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

Arguments

Type	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

Arguments

Type	Intent		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_ctrsv(uplo, trans, diag, n, a, lda, x, incx)

CTRSV 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	Intent		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=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
complex(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

DTRSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=dp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=dp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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

STRSV solves one of the systems of equations Ax = b, or ATx = 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	Intent		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
real(kind=sp),	intent(in)	::	a(lda,*)
integer(kind=ilp),	intent(in)	::	lda
real(kind=sp),	intent(inout)	::	x(*)
integer(kind=ilp),	intent(in)	::	incx

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	Intent		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

stdlib_linalg_blas Module

Contents

Interfaces

Uses

Interfaces

public interface axpy

public pure subroutine caxpy(n, ca, cx, incx, cy, incy)

Arguments

public pure subroutine daxpy(n, da, dx, incx, dy, incy)

Arguments

public pure subroutine saxpy(n, sa, sx, incx, sy, incy)

Arguments

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

Arguments

public pure subroutine stdlib_caxpy(n, ca, cx, incx, cy, incy)

Arguments

public pure subroutine stdlib_daxpy(n, da, dx, incx, dy, incy)

Arguments

public pure subroutine stdlib_saxpy(n, sa, sx, incx, sy, incy)

Arguments

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

Arguments

public interface copy

public pure subroutine ccopy(n, cx, incx, cy, incy)

Arguments

public pure subroutine dcopy(n, dx, incx, dy, incy)

Arguments

public pure subroutine scopy(n, sx, incx, sy, incy)

Arguments

public pure subroutine zcopy(n, zx, incx, zy, incy)

Arguments

public pure subroutine stdlib_ccopy(n, cx, incx, cy, incy)

Arguments

public pure subroutine stdlib_dcopy(n, dx, incx, dy, incy)

Arguments

public pure subroutine stdlib_scopy(n, sx, incx, sy, incy)

Arguments

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

Arguments

public interface dot

public pure function ddot(n, dx, incx, dy, incy)

Arguments

Return Value real(kind=dp)

public pure function sdot(n, sx, incx, sy, incy)

Arguments

Return Value real(kind=sp)

public pure function stdlib_ddot(n, dx, incx, dy, incy)

Arguments

Return Value real(kind=dp)

public pure function stdlib_sdot(n, sx, incx, sy, incy)

Arguments

Return Value real(kind=sp)

public interface dotc

public pure function cdotc(n, cx, incx, cy, incy)

Arguments

Return Value complex(kind=sp)

public pure function zdotc(n, zx, incx, zy, incy)

Arguments

Return Value complex(kind=dp)

public pure function stdlib_cdotc(n, cx, incx, cy, incy)

Arguments

Return Value complex(kind=sp)

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

Arguments

Return Value complex(kind=dp)

public interface dotu

public pure function cdotu(n, cx, incx, cy, incy)

Arguments

Return Value complex(kind=sp)

public pure function zdotu(n, zx, incx, zy, incy)

Arguments

Return Value complex(kind=dp)

public pure function stdlib_cdotu(n, cx, incx, cy, incy)

Arguments

Return Value complex(kind=sp)

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

Arguments

Return Value complex(kind=dp)

public interface gbmv

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