README.md

Extended BLAS

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

Usage

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

ns

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

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

• cfill( N, alpha, x, strideX ): fill a single-precision complex floating-point strided array with a specified scalar constant.
• csum( N, x, strideX ): calculate the sum of single-precision complex floating-point strided array elements.
• csumkbn( N, x, strideX ): calculate the sum of single-precision complex floating-point strided array elements using an improved Kahan–Babuška algorithm.
• czeroTo( N, x, strideX ): fill a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by 1 starting from zero.
• dapx( N, alpha, x, strideX ): add a scalar constant to each element in a double-precision floating-point strided array.
• dapxsum( N, alpha, x, strideX ): add a scalar constant to each double-precision floating-point strided array element and compute the sum.
• dapxsumkbn( N, alpha, x, strideX ): add a scalar constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm.
• dapxsumkbn2( N, alpha, x, strideX ): add a scalar constant to each double-precision floating-point strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm.
• dapxsumors( N, alpha, x, strideX ): add a scalar constant to each double-precision floating-point strided array element and compute the sum using ordinary recursive summation.
• dapxsumpw( N, alpha, x, strideX ): add a scalar constant to each double-precision floating-point strided array element and compute the sum using pairwise summation.
• dasumpw( N, x, strideX ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements using pairwise summation.
• dcircshift( N, k, x, strideX ): circularly shift the elements of a double-precision floating-point strided array by a specified number of positions.
• dcusum( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements.
• dcusumkbn( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• dcusumkbn2( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• dcusumors( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements using ordinary recursive summation.
• dcusumpw( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements using pairwise summation.
• dfill( N, alpha, x, strideX ): fill a double-precision floating-point strided array with a specified scalar constant.
• dindexOfRow( order, M, N, A, LDA, x, strideX, workspace, strideW ): return the index of the first row in a double-precision floating-point input matrix which has the same elements as a provided search vector.
• dindexOf( N, searchElement, x, strideX ): return the first index of a specified search element in a double-precision floating-point strided array.
• dlastIndexOf( N, searchElement, x, strideX ): return the last index of a specified search element in a double-precision floating-point strided array.
• dlinspace( N, start, stop, endpoint, x, strideX ): fill a double-precision floating-point strided array with linearly spaced values over a specified interval.
• dnanasum( N, x, strideX ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements, ignoring NaN values.
• dnanasumors( N, x, strideX ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• dnancusumkbn( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of double-precision floating-point strided array elements ignoring NaN values and using an improved Kahan–Babuška algorithm.
• dnannsum( N, x, strideX, out, strideOut ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values.
• dnannsumkbn( N, x, strideX, out, strideOut ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• dnannsumkbn2( N, x, strideX, out, strideOut ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.
• dnannsumors( N, x, strideX, out, strideOut ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• dnannsumpw( N, x, strideX, out, strideOut ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using pairwise summation.
• dnansum( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values.
• dnansumkbn( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• dnansumkbn2( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.
• dnansumors( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• dnansumpw( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using pairwise summation.
• doneTo( N, x, strideX ): fill a double-precision floating-point strided array with linearly spaced numeric elements which increment by 1 starting from one.
• drev( N, x, strideX ): reverse a double-precision floating-point strided array in-place.
• drrss( N, x, strideX, y, strideY ): calculate the square root of the residual sum of squares of two double-precision floating-point strided arrays.
• drss( N, x, strideX, y, strideY ): calculate the residual sum of squares of two double-precision floating-point strided arrays.
• drssbl( N, x, strideX, y, strideY ): calculate the residual sum of squares of two double-precision floating-point strided arrays using Blue's algorithm.
• drsskbn( N, x, strideX, y, strideY ): calculate the residual sum of squares of two double-precision floating-point strided arrays using an improved Kahan–Babuška algorithm.
• dsapxsum( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element, and compute the sum using extended accumulation and returning an extended precision result.
• dsapxsumpw( N, alpha, x, strideX ): add a constant to each single-precision floating-point strided array element, and compute the sum using pairwise summation with extended accumulation and returning an extended precision result.
• dsnannsumors( N, x, strideX, out, strideOut ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
• dsnansum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values, using extended accumulation, and returning an extended precision result.
• dsnansumors( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
• dsnansumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values, using pairwise summation with extended accumulation, and returning an extended precision result.
• dsort( N, order, x, strideX ): sort a double-precision floating-point strided array.
• dsort2hp( N, order, x, strideX, y, strideY ): simultaneously sort two double-precision floating-point strided arrays based on the sort order of the first array using heapsort.
• dsort2ins( N, order, x, strideX, y, strideY ): simultaneously sort two double-precision floating-point strided arrays based on the sort order of the first array using insertion sort.
• dsort2sh( N, order, x, strideX, y, strideY ): simultaneously sort two double-precision floating-point strided arrays based on the sort order of the first array using Shellsort.
• dsorthp( N, order, x, strideX ): sort a double-precision floating-point strided array using heapsort.
• dsortins( N, order, x, strideX ): sort a double-precision floating-point strided array using insertion sort.
• dsortsh( N, order, x, stride ): sort a double-precision floating-point strided array using Shellsort.
• dssum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using extended accumulation and returning an extended precision result.
• dssumors( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using ordinary recursive summation with extended accumulation and returning an extended precision result.
• dssumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using pairwise summation with extended accumulation and returning an extended precision result.
• dsum( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements.
• dsumkbn( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• dsumkbn2( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• dsumors( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements using ordinary recursive summation.
• dsumpw( N, x, strideX ): calculate the sum of double-precision floating-point strided array elements using pairwise summation.
• dzeroTo( N, x, strideX ): fill a double-precision floating-point strided array with linearly spaced numeric elements which increment by 1 starting from zero.
• gapx( N, alpha, x, strideX ): add a scalar constant to each element in a strided array.
• gapxsum( N, alpha, x, strideX ): add a scalar constant to each strided array element and compute the sum.
• gapxsumkbn( N, alpha, x, strideX ): add a scalar constant to each strided array element and compute the sum using an improved Kahan–Babuška algorithm.
• gapxsumkbn2( N, alpha, x, strideX ): add a scalar constant to each strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm.
• gapxsumors( N, alpha, x, strideX ): add a scalar constant to each strided array element and compute the sum using ordinary recursive summation.
• gapxsumpw( N, alpha, x, strideX ): add a scalar constant to each strided array element and compute the sum using pairwise summation.
• gasumpw( N, x, strideX ): calculate the sum of absolute values (L1 norm) of strided array elements using pairwise summation.
• gcircshift( N, k, x, strideX ): circularly shift the elements of a strided array by a specified number of positions.
• gconjoin( N, prefix, suffix, conjunction, oxfordComma, x, strideX ): return a string created by joining strided array elements into a human-readable list using a conjunction.
• gcusum( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of strided array elements.
• gcusumkbn( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of strided array elements using an improved Kahan–Babuška algorithm.
• gcusumkbn2( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of strided array elements using a second-order iterative Kahan–Babuška algorithm.
• gcusumors( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of strided array elements using ordinary recursive summation.
• gcusumpw( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of strided array elements using pairwise summation.
• gfillBy( N, x, strideX, clbk[, thisArg] ): fill a strided array according to a provided callback function.
• gfill( N, alpha, x, strideX ): fill a strided array with a specified scalar constant.
• gfindIndex( N, x, strideX, clbk[, thisArg] ): return the index of the first element which passes a test implemented by a predicate function.
• gfindLastIndex( N, x, strideX, clbk[, thisArg] ): return the index of the last element which passes a test implemented by a predicate function.
• gindexOfRow( order, M, N, A, LDA, x, strideX ): return the index of the first row in an input matrix which has the same elements as a provided search vector.
• gindexOf( N, searchElement, x, strideX ): return the first index of a specified search element in a strided array.
• gjoinBetween( N, prefix, suffix, x, strideX, separators, strideS ): return a string by joining strided array elements using a specified separator for each pair of consecutive elements.
• gjoin( N, separator, x, strideX ): return a string created by joining strided array elements using a specified separator.
• glastIndexOf( N, searchElement, x, strideX ): return the last index of a specified search element in a strided array.
• glinspace( N, start, stop, endpoint, x, strideX ): fill a strided array with linearly spaced values over a specified interval.
• gnannsumkbn( N, x, strideX, out, strideOut ): calculate the sum of strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• gnannsumpw( N, x, strideX, out, strideOut ): calculate the sum of strided array elements, ignoring NaN values and using pairwise summation.
• gnansum( N, x, strideX ): calculate the sum of strided array elements, ignoring NaN values.
• gnansumkbn( N, x, strideX ): calculate the sum of strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• gnansumkbn2( N, x, strideX ): calculate the sum of strided array elements, ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.
• gnansumors( N, x, strideX ): calculate the sum of strided array elements, ignoring NaN values and using ordinary recursive summation.
• gnansumpw( N, x, strideX ): calculate the sum of strided array elements, ignoring NaN values and using pairwise summation.
• grev( N, x, strideX ): reverse a strided array in-place.
• gsort( N, order, x, strideX ): sort a strided array.
• gsort2hp( N, order, x, strideX, y, strideY ): simultaneously sort two strided arrays based on the sort order of the first array using heapsort.
• gsort2ins( N, order, x, strideX, y, strideY ): simultaneously sort two strided arrays based on the sort order of the first array using insertion sort.
• gsort2sh( N, order, x, strideX, y, strideY ): simultaneously sort two strided arrays based on the sort order of the first array using Shellsort.
• gsorthp( N, order, x, strideX ): sort a strided array using heapsort.
• gsortins( N, order, x, strideX ): sort a strided array using insertion sort.
• gsortsh( N, order, x, strideX ): sort a strided array using Shellsort.
• gsum( N, x, strideX ): calculate the sum of strided array elements.
• gsumkbn( N, x, strideX ): calculate the sum of strided array elements using an improved Kahan–Babuška algorithm.
• gsumkbn2( N, x, strideX ): calculate the sum of strided array elements using a second-order iterative Kahan–Babuška algorithm.
• gsumors( N, x, strideX ): calculate the sum of strided array elements using ordinary recursive summation.
• gsumpw( N, x, strideX ): calculate the sum of strided array elements using pairwise summation.
• gzeroTo( N, x, strideX ): fill a strided array with linearly spaced numeric elements which increment by 1 starting from zero.
• ndarray: base ndarray extended BLAS functions.
• sapx( N, alpha, x, strideX ): add a scalar constant to each element in a single-precision floating-point strided array.
• sapxsum( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum.
• sapxsumkbn( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm.
• sapxsumkbn2( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm.
• sapxsumors( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using ordinary recursive summation.
• sapxsumpw( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using pairwise summation.
• sasumpw( N, x, strideX ): calculate the sum of absolute values (L1 norm) of single-precision floating-point strided array elements using pairwise summation.
• scircshift( N, k, x, strideX ): circularly shift the elements of a single-precision floating-point strided array by a specified number of positions.
• scusum( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of single-precision floating-point strided array elements.
• scusumkbn( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of single-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• scusumkbn2( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of single-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• scusumors( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of single-precision floating-point strided array elements using ordinary recursive summation.
• scusumpw( N, sum, x, strideX, y, strideY ): calculate the cumulative sum of single-precision floating-point strided array elements using pairwise summation.
• sdsapxsum( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using extended accumulation.
• sdsapxsumpw( N, alpha, x, strideX ): add a scalar constant to each single-precision floating-point strided array element and compute the sum using pairwise summation with extended accumulation.
• sdsnansum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using extended accumulation.
• sdsnansumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using pairwise summation with extended accumulation.
• sdssum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using extended accumulation.
• sdssumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using pairwise summation with extended accumulation.
• sfill( N, alpha, x, strideX ): fill a single-precision floating-point strided array with a specified scalar constant.
• sindexOfRow( order, M, N, A, LDA, x, strideX, workspace, strideW ): return the index of the first row in a single-precision floating-point input matrix which has the same elements as a provided search vector.
• sindexOf( N, searchElement, x, strideX ): return the first index of a specified search element in a single-precision floating-point strided array.
• slastIndexOf( N, searchElement, x, strideX ): return the last index of a specified search element in a single-precision floating-point strided array.
• slinspace( N, start, stop, endpoint, x, strideX ): fill a single-precision floating-point strided array with linearly spaced values over a specified interval.
• snansum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values.
• snansumkbn( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• snansumkbn2( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.
• snansumors( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• snansumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using pairwise summation.
• soneTo( N, x, strideX ): fill a single-precision floating-point strided array with linearly spaced numeric elements which increment by 1 starting from one.
• srev( N, x, strideX ): reverse a single-precision floating-point strided array in-place.
• ssort2hp( N, order, x, strideX, y, strideY ): simultaneously sort two single-precision floating-point strided arrays based on the sort order of the first array using heapsort.
• ssort2ins( N, order, x, strideX, y, strideY ): simultaneously sort two single-precision floating-point strided arrays based on the sort order of the first array using insertion sort.
• ssort2sh( N, order, x, strideX, y, strideY ): simultaneously sort two single-precision floating-point strided arrays based on the sort order of the first array using Shellsort.
• ssorthp( N, order, x, stride ): sort a single-precision floating-point strided array using heapsort.
• ssortins( N, order, x, stride ): sort a single-precision floating-point strided array using insertion sort.
• ssortsh( N, order, x, stride ): sort a single-precision floating-point strided array using Shellsort.
• ssum( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements.
• ssumkbn( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• ssumkbn2( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• ssumors( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using ordinary recursive summation.
• ssumpw( N, x, strideX ): calculate the sum of single-precision floating-point strided array elements using pairwise summation.
• szeroTo( N, x, strideX ): fill a single-precision floating-point strided array with linearly spaced numeric elements which increment by 1 starting from zero.
• wasm: extensions to basic linear algebra subprograms (BLAS) compiled to WebAssembly.
• zfill( N, alpha, x, strideX ): fill a double-precision complex floating-point strided array with a specified scalar constant.
• zsum( N, x, strideX ): calculate the sum of double-precision complex floating-point strided array elements.
• zsumkbn( N, x, strideX ): calculate the sum of double-precision complex floating-point strided array elements using an improved Kahan–Babuška algorithm.
• zzeroTo( N, x, strideX ): fill a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by 1 starting from zero.

Examples

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

console.log( objectKeys( ns ) );