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 ) );