BLAS

Base (i.e., lower-level) basic linear algebra subprograms (BLAS).

Usage

var blas = require( '@stdlib/blas/base' );

blas

Namespace for "base" (i.e., lower-level) basic linear algebra subprograms (BLAS).

var o = blas;
// returns {...}

BLAS Level 1

caxpy( N, ca, cx, strideX, cy, strideY ): scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector.
ccopy( N, x, strideX, y, strideY ): copy values from one complex single-precision floating-point vector to another complex single-precision floating-point vector.
cscal( N, ca, cx, strideX ): scales a single-precision complex floating-point vector by a single-precision complex floating-point constant.
csrot( N, cx, strideX, cy, strideY, c, s ): applies a plane rotation.
cswap( N, x, strideX, y, strideY ): interchange two complex single-precision floating-point vectors.
dasum( N, x, stride ): compute the sum of absolute values (L1 norm).
daxpy( N, alpha, x, strideX, y, strideY ): multiply a vector x by a constant alpha and add the result to y.
dcopy( N, x, strideX, y, strideY ): copy values from x into y.
ddot( N, x, strideX, y, strideY ): calculate the dot product of two double-precision floating-point vectors.
dnrm2( N, x, stride ): calculate the L2-norm of a double-precision floating-point vector.
drot( N, x, strideX, y, strideY, c, s ): apply a plane rotation.
drotg( a, b ): construct a Givens plane rotation.
drotm( N, x, strideX, y, strideY, param ): apply a modified Givens plane rotation.
dscal( N, alpha, x, stride ): multiply a double-precision floating-point vector x by a constant alpha.
dsdot( N, x, strideX, y, strideY ): calculate the dot product with extended accumulation and result of two single-precision floating-point vectors.
dswap( N, x, strideX, y, strideY ): interchange two double-precision floating-point vectors.
dznrm2( N, zx, strideX ): compute the L2-norm of a complex double-precision floating-point vector.
gasum( N, x, stride ): compute the sum of absolute values (L1 norm).
gaxpy( N, alpha, x, strideX, y, strideY ): multiply x by a constant alpha and add the result to y.
gcopy( N, x, strideX, y, strideY ): copy values from x into y.
gdot( N, x, strideX, y, strideY ): calculate the dot product of two vectors.
gnrm2( N, x, stride ): calculate the L2-norm of a vector.
gscal( N, alpha, x, stride ): multiply a vector x by a constant alpha.
gswap( N, x, strideX, y, strideY ): interchange two vectors.
idamax( N, x, strideX ): find the index of the first element having the maximum absolute value.
isamax( N, x, strideX ): find the index of the first element having the maximum absolute value.
sasum( N, x, stride ): compute the sum of absolute values (L1 norm).
saxpy( N, alpha, x, strideX, y, strideY ): multiply a vector x by a constant alpha and add the result to y.
scasum( N, cx, strideX ): compute the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector.
scnrm2( N, cx, strideX ): compute the L2-norm of a complex single-precision floating-point vector.
scopy( N, x, strideX, y, strideY ): copy values from x into y.
sdot( N, x, strideX, y, strideY ): calculate the dot product of two single-precision floating-point vectors.
sdsdot( N, scalar, x, strideX, y, strideY ): calculate the dot product of two single-precision floating-point vectors with extended accumulation.
snrm2( N, x, stride ): calculate the L2-norm of a single-precision floating-point vector.
srot( N, x, strideX, y, strideY, c, s ): apply a plane rotation.
srotg( a, b ): construct a Givens plane rotation.
srotm( N, x, strideX, y, strideY, param ): apply a modified Givens plane rotation.
sscal( N, alpha, x, stride ): multiply a single-precision floating-point vector x by a constant alpha.
sswap( N, x, strideX, y, strideY ): interchange two single-precision floating-point vectors.
zaxpy( N, za, zx, strideX, zy, strideY ): scale a double-precision complex floating-point vector by a double-precision complex floating-point constant and add the result to a double-precision complex floating-point vector.
zcopy( N, x, strideX, y, strideY ): copy values from one complex double-precision floating-point vector to another complex double-precision floating-point vector.
zdrot( N, zx, strideX, zy, strideY, c, s ): applies a plane rotation.
zscal( N, za, zx, strideX ): scales a double-precision complex floating-point vector by a double-precision complex floating-point constant.
zswap( N, x, strideX, y, strideY ): interchange two complex double-precision floating-point vectors.

BLAS Level 2

dspmv( order, uplo, N, α, AP, x, sx, β, y, sy ): perform the matrix-vector operation y = α*A*x + β*y where α and β are scalars, x and y are N element vectors and, A is an N by N symmetric matrix supplied in packed form.
dsymv( order, uplo, N, α, A, LDA, x, sx, β, y, sy ): perform the matrix-vector operation y = α*A*x + β*y where α and β are scalars, x and y are N element vectors, and A is an N by N symmetric matrix.
dsyr( order, uplo, N, α, x, sx, A, LDA ): perform the symmetric rank 1 operation A = α*x*x^T + A.
dsyr2( order, uplo, N, α, x, sx, y, sy, A, LDA ): perform the symmetric rank 2 operation A = α*x*y^T + α*y*x^T + A.
dtrmv( order, uplo, trans, diag, N, A, LDA, x, sx ): perform one of the matrix-vector operations x = A*x or x = A^T*x.
sgemv( ord, trans, M, N, α, A, LDA, x, sx, β, y, sy ): perform one of the matrix-vector operations y = α*A*x + β*y or y = α*A^T*x + β*y.
sspmv( order, uplo, N, α, AP, x, sx, β, y, sy ): perform the matrix-vector operation y = α*A*x + β*y where α and β are scalars, x and y are N element vectors and, A is an N by N symmetric matrix supplied in packed form.
ssymv( order, uplo, N, α, A, LDA, x, sx, β, y, sy ): perform the matrix-vector operation y = α*A*x + β*y where α and β are scalars, x and y are N element vectors, and A is an N by N symmetric matrix.
ssyr( order, uplo, N, α, x, sx, A, LDA ): perform the symmetric rank 1 operation A = α*x*x**T + A.
ssyr2( order, uplo, N, α, x, sx, y, sy, A, LDA ): perform the symmetric rank 2 operation A = α*x*y^T + α*y*x^T + A.
strmv( order, uplo, trans, diag, N, A, LDA, x, sx ): perform one of the matrix-vector operations x = A*x or x = A^T*x.

BLAS Level 3

Scalar Operations

dcabs1( z ): compute the sum of the absolute values of the real part and imaginary components of a double-precision complex floating-point number.
scabs1( z ): compute the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point number.

Auxiliary BLAS

Utilities

assert: base BLAS assertion utilities.
diagonalTypeEnum2Str( value ): return the BLAS diagonal type string associated with a BLAS diagonal type enumeration constant.
diagonalTypeResolveEnum( value ): return the enumeration constant associated with a supported BLAS diagonal type value.
diagonalTypeResolveStr( value ): return the diagonal type string associated with a supported BLAS diagonal type value.
diagonalTypeStr2Enum( diagonal ): return the enumeration constant associated with a BLAS diagonal type.
diagonalTypes(): BLAS diagonal element types.
layoutEnum2Str( layout ): return the BLAS memory layout string associated with a BLAS memory layout enumeration constant.
layoutResolveEnum( layout ): return the enumeration constant associated with a supported BLAS memory layout value.
layoutResolveStr( layout ): return the layout string associated with a supported BLAS memory layout value.
layoutStr2Enum( layout ): return the enumeration constant associated with a BLAS memory layout string.
layouts(): BLAS memory layouts.
matrixTriangleEnum2Str( value ): return the BLAS matrix triangle string associated with a BLAS matrix triangle enumeration constant.
matrixTriangleResolveEnum( value ): return the enumeration constant associated with a supported BLAS matrix triangle value.
matrixTriangleResolveStr( value ): return the matrix triangle string associated with a supported BLAS matrix triangle value.
matrixTriangleStr2Enum( operation ): return the enumeration constant associated with a BLAS matrix triangle.
matrixTriangles(): BLAS matrix triangles.
operationSideEnum2Str( operation ): return the BLAS operation side string associated with a BLAS operation side enumeration constant.
operationSideResolveEnum( operation ): return the enumeration constant associated with a supported BLAS operation side value.
operationSideResolveStr( operation ): return the operation side string associated with a supported BLAS operation side value.
operationSideStr2Enum( operation ): return the enumeration constant associated with a BLAS operation side.
operationSides(): BLAS operation sides.
transposeOperationEnum2Str( operation ): return the BLAS transpose operation string associated with a BLAS transpose operation enumeration constant.
transposeOperationResolveEnum( operation ): return the enumeration constant associated with a supported BLAS transpose operation value.
transposeOperationResolveStr( operation ): return the transpose operation string associated with a supported BLAS transpose operation value.
transposeOperationStr2Enum( operation ): return the enumeration constant associated with a BLAS transpose operation.
transposeOperations(): BLAS transpose operations.

Examples

var objectKeys = require( '@stdlib/utils/keys' );
var blas = require( '@stdlib/blas/base' );

console.log( objectKeys( blas ) );