library.blas Submodule

Module Summary

Interfaces for the NAG Mark 30.0 blas Chapter.

blas - Linear Algebra Support Routines

This module is concerned with basic linear algebra functions which perform elementary algebraic operations involving scalars, vectors and matrices. It includes functions which conform to the specifications of the BLAS (Basic Linear Algebra Subprograms).

Functionality Index

Level 0 (Scalar) operations

complex numbers

apply similarity rotation to $2\times 2$ Hermitian matrix: zrot2()

generate a plane rotation, storing the tangent, real cosine: zrotgc()

generate a plane rotation, storing the tangent, real sine: zrotgs()

quotient of two numbers, with overflow flag: zdiv()

recover cosine and sine from given tangent, real cosine: zcsg()

recover cosine and sine from given tangent, real sine: zcsgs()

real numbers

apply similarity rotation to $2\times 2$ symmetric matrix: drot2()

compute $\sqrt{(a^2+b^2)}$: dpyth()

compute Euclidean norm from scaled form: dnorm()

eigenvalue of $2\times 2$ symmetric matrix: deig2()

generate a Jacobi plane rotation: drotj()

generate a plane rotation: drotg()

generate a plane rotation storing the tangent: drotgc()

quotient of two numbers, with overflow flag: ddiv()

recover cosine and sine from given tangent: dcsg()

Level 1 (Vector) operations

complex vector(s)

add scalar times a vector to another vector: zaxpy()

apply a complex plane rotation: zcrot()

apply an elementary reflection to a vector: zhous()

apply a real plane rotation: zdrot()

apply plane rotation

real cosine, complex sine: zrot()

broadcast a scalar into a vector: zload()

copy a real vector to a complex vector: zdcopy()

copy a vector: zcopy()

dot product of two vectors, conjugated: zdotc()

dot product of two vectors, unconjugated: zdotu()

Euclidean norm of a vector: dznrm2()

generate an elementary reflection: zhousg()

generate a sequence of plane rotations: zsrotg()

index of element of largest absolute value: izamax()

multiply vector by a complex scalar: zscal()

multiply vector by a complex scalar, preserving input vector: zaxpzy()

multiply vector by a real scalar: zdscal()

multiply vector by a real scalar, preserving input vector: zdaxpzy()

multiply vector by complex diagonal matrix: zdscl()

multiply vector by real diagonal matrix: zddscl()

multiply vector by reciprocal of a real scalar: zdrscl()

negate a vector: znegv()

sum of absolute values of vector-elements: dzasum()

swap two vectors: zswap()

update Euclidean norm in scaled form: dzssq()

integer vector(s)

broadcast a scalar into a vector: iload()

copy a vector: icopy()

real vector(s)

add scalar times a vector to another vector: daxpy()

apply an elementary reflection to a vector (Linpack style): dlhous()

apply an elementary reflection to a vector (NAG style): dnhous()

apply a symmetric plane rotation to two vectors: drots()

apply plane rotation: drot()

broadcast a scalar into a vector: dload()

copy a vector: dcopy()

cosine of angle between two vectors: dvcos()

dot product of two vectors: ddot()

elements of largest and smallest absolute value: darang()

Euclidean norm of a vector: dnrm2()

generate an elementary reflection (Linpack style): dlhousg()

generate an elementary reflection (NAG style): dnhousg()

generate a sequence of plane rotations: dsrotg()

index of element of largest absolute value: idamax()

index of last non-negligible element: idrank()

multiply vector by a scalar: dscal()

multiply vector by a scalar, preserving input vector: axpzy()

multiply vector by diagonal matrix: ddscl()

multiply vector by reciprocal of a scalar: drscl()

negate a vector: dnegv()

sum of absolute values of vector-elements: dasum()

swap two vectors: dswap()

update Euclidean norm in scaled form: dssq()

weighted Euclidean norm of a vector: dnrm2w()

Level 2 (Matrix-vector and matrix) operations

complex matrix and vector(s)

apply sequence of plane rotations to a rectangular matrix

complex cosine, real sine: zgesrs()

real cosine, complex sine: zgesrc()

real cosine and sine: zsgesr()

compute a norm or the element of largest absolute value

band matrix: zlangb()

general matrix: zlange()

Hermitian band matrix: zlanhb()

Hermitian matrix: zlanhe()

Hermitian matrix, packed form: zlanhp()

Hermitian matrix, RFP format: zlanhf()

Hermitian tridiagonal matrix: zlanht()

Hessenberg matrix: zlanhs()

symmetric band matrix: zlansb()

symmetric matrix: zlansy()

symmetric matrix, packed form: zlansp()

trapezoidal matrix: zlantr()

triangular band matrix: zlantb()

triangular matrix, packed form: zlantp()

tridiagonal matrix: zlangt()

compute upper Hessenberg matrix by applying sequence of plane rotations to an upper triangular matrix: zutsrh()

compute upper spiked matrix by applying sequence of plane rotations to an upper triangular matrix: zutsrs()

matrix initialization: zmload()

matrix-vector product

Hermitian band matrix: zhbmv()

Hermitian matrix: zhemv()

Hermitian packed matrix: zhpmv()

rectangular band matrix: zgbmv()

rectangular matrix: zgemv()

symmetric matrix: zsymv()

symmetric packed matrix: zspmv()

triangular band matrix: ztbmv()

triangular matrix: ztrmv()

triangular packed matrix: ztpmv()

permute rows or columns of a matrix

permutations represented by an integer array: zgeap()

permutations represented by a real array: zgeapr()

$QR$ factorization by sequence of plane rotations

of rank-1 update of upper triangular matrix: zutr1()

of upper triangular matrix augmented by a full row: zutupd()

$QR$ factorization of $UZ$ or $RQ$ factorization of $ZU$, where $U$ is upper triangular and $Z$ is a sequence of plane rotations: zutsqr()

$QR$ or $RQ$ factorization by sequence of plane rotations

of upper Hessenberg matrix: zuhqr()

of upper spiked matrix: zusqr()

rank-1 update

Hermitian matrix: zher()

Hermitian packed matrix: zhpr()

rectangular matrix, conjugated vector: zgerc()

rectangular matrix, unconjugated vector: zgeru()

symmetric matrix: zsyr()

symmetric packed matrix: zspr()

rank-2 update

Hermitian matrix: zher2()

Hermitian packed matrix: zhpr2()

matrix copy, rectangular or trapezoidal: zmcopy()

solution of a system of equations

triangular band matrix: ztbsv()

triangular matrix: ztrsv()

triangular packed matrix: ztpsv()

unitary similarity transformation of a Hermitian matrix

as sequence of plane rotations: zhesrc()

real matrix and vector(s)

apply sequence of plane rotations to a rectangular matrix: dgesrc()

compute a norm or the element of largest absolute value

band matrix: dlangb()

general matrix: dlange()

Hessenberg matrix: dlanhs()

matrix initialization: dmload()

symmetric band matrix: dlansb()

symmetric matrix: dlansy()

symmetric matrix, packed form: dlansp()

symmetric matrix, RFP format: dlansf()

symmetric tridiagonal matrix: dlanst()

trapezoidal matrix: dlantr()

triangular band matrix: dlantb()

triangular matrix, packed form: dlantp()

tridiagonal matrix: dlangt()

compute upper Hessenberg matrix by applying sequence of plane rotations to an upper triangular matrix: dutsrh()

compute upper spiked matrix by applying sequence of plane rotations to an upper triangular matrix: dutsrs()

matrix-vector product

rectangular band matrix: dgbmv()

rectangular matrix: dgemv()

symmetric band matrix: dsbmv()

symmetric matrix: dsymv()

symmetric packed matrix: dspmv()

triangular band matrix: dtbmv()

triangular matrix: dtrmv()

triangular packed matrix: dtpmv()

orthogonal similarity transformation of a symmetric matrix

as sequence of plane rotations: dsysrc()

permute rows or columns of a matrix

permutations represented by an integer array: dgeap()

permutations represented by a real array: dgeapr()

$QR$ factorization by sequence of plane rotations

of rank-1 update of upper triangular matrix: dutr1()

of upper triangular matrix augmented by a full row: dutupd()

$QR$ factorization of $UZ$ or $RQ$ factorization of $ZU$, where $U$ is upper triangular and $Z$ is a sequence of plane rotations: dutsqr()

$QR$ or $RQ$ factorization by sequence of plane rotations

of upper Hessenberg matrix: duhqr()

of upper spiked matrix: dusqr()

rank-1 update

rectangular matrix: dger()

symmetric matrix: dsyr()

symmetric packed matrix: dspr()

rank-2 update

matrix copy, rectangular or trapezoidal: dmcopy()

symmetric matrix: dsyr2()

symmetric packed matrix: dspr2()

solution of a system of equations

triangular band matrix: dtbsv()

triangular matrix: dtrsv()

triangular packed matrix: dtpsv()

Level 3 (Matrix-matrix) operations

complex matrices

matrix-matrix product

one matrix Hermitian: zhemm()

one matrix symmetric: zsymm()

one matrix triangular: ztrmm()

two rectangular matrices: zgemm()

rank-$2k$ update

of a Hermitian matrix: zher2k()

of a symmetric matrix: zsyr2k()

rank-$k$ update

of a Hermitian matrix: zherk()

of a Hermitian matrix, RFP format: zhfrk()

of a symmetric matrix: zsyrk()

solution of triangular systems of equations: ztrsm()

solution of triangular systems of equations, RFP format: ztfsm()

real matrices

matrix-matrix product

one matrix symmetric: dsymm()

one matrix triangular: dtrmm()

rectangular matrices: dgemm()

rank-$2k$ update of a symmetric matrix: dsyr2k()

rank-$k$ update

of a symmetric matrix: dsyrk()

of a symmetric matrix, RFP format: dsfrk()

solution of triangular systems of equations: dtrsm()

solution of triangular systems of equations, RFP format: dtfsm()

Sparse level 1 (vector) operations

complex vector(s)

add scalar times sparse vector to a full vector: zaxpyi()

dot product of a sparse and a full vector (conjugated): zdotci()

dot product of a sparse and a full vector (unconjugated): zdotui()

gather and set to zero a sparse vector: zgthrz()

gather sparse vector: zgthr()

scatter sparse vector: zsctr()

real vector(s)

add scalar times sparse vector to a full vector: daxpyi()

apply plane rotation to a sparse and a full vector: droti()

dot product of a sparse and a full vector: ddoti()

gather and set to zero a sparse vector: dgthrz()

gather sparse vector: dgthr()

scatter sparse vector: dsctr()

For full information please refer to the NAG Library document

https://support.nag.com/numeric/nl/nagdoc_30/flhtml/f06/f06intro.html