time-to-botec/squiggle/node_modules/@stdlib/blas/ext/base

Extended BLAS

Standard library extensions to base basic linear algebra subprograms (BLAS).

Usage

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

extblas

Standard library extensions to base basic linear algebra subprograms (BLAS).

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

• dapx( N, alpha, x, stride ): add a constant to each element in a double-precision floating-point strided array.
• dapxsum( N, alpha, x, stride ): add a constant to each double-precision floating-point strided array element and compute the sum.
• dapxsumkbn( N, alpha, x, stride ): add a 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, stride ): add a 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, stride ): add a constant to each double-precision floating-point strided array element and compute the sum using ordinary recursive summation.
• dapxsumpw( N, alpha, x, stride ): add a constant to each double-precision floating-point strided array element and compute the sum using pairwise summation.
• dasumpw( N, x, stride ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements using pairwise summation.
• 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, stride ): fill a double-precision floating-point strided array with a specified scalar constant.
• dnanasum( N, x, stride ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements, ignoring NaN values.
• dnanasumors( N, x, stride ): calculate the sum of absolute values (L1 norm) of double-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• 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, stride ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values.
• dnansumkbn( N, x, stride ): 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, stride ): 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, stride ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• dnansumpw( N, x, stride ): calculate the sum of double-precision floating-point strided array elements, ignoring NaN values and using pairwise summation.
• drev( N, x, stride ): reverse a double-precision floating-point strided array in-place.
• dsapxsum( N, alpha, x, stride ): add a 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, stride ): 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, stride ): 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, stride ): 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, stride ): 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.
• 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, stride ): sort a double-precision floating-point strided array using heapsort.
• dsortins( N, order, x, stride ): 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, stride ): calculate the sum of single-precision floating-point strided array elements using extended accumulation and returning an extended precision result.
• dssumors( N, x, stride ): 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, stride ): 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, stride ): calculate the sum of double-precision floating-point strided array elements.
• dsumkbn( N, x, stride ): calculate the sum of double-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• dsumkbn2( N, x, stride ): calculate the sum of double-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• dsumors( N, x, stride ): calculate the sum of double-precision floating-point strided array elements using ordinary recursive summation.
• dsumpw( N, x, stride ): calculate the sum of double-precision floating-point strided array elements using pairwise summation.
• gapx( N, alpha, x, stride ): add a constant to each element in a strided array.
• gapxsum( N, alpha, x, stride ): add a constant to each strided array element and compute the sum.
• gapxsumkbn( N, alpha, x, stride ): add a constant to each strided array element and compute the sum using an improved Kahan–Babuška algorithm.
• gapxsumkbn2( N, alpha, x, stride ): add a constant to each strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm.
• gapxsumors( N, alpha, x, stride ): add a constant to each strided array element and compute the sum using ordinary recursive summation.
• gapxsumpw( N, alpha, x, stride ): add a constant to each strided array element and compute the sum using pairwise summation.
• gasumpw( N, x, stride ): calculate the sum of absolute values (L1 norm) of strided array elements using pairwise summation.
• 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, stride, clbk[, thisArg] ): fill a strided array according to a provided callback function.
• gfill( N, alpha, x, stride ): fill a strided array with a specified scalar constant.
• gnannsumkbn( N, x, strideX, out, strideOut ): calculate the sum of strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• gnansum( N, x, stride ): calculate the sum of strided array elements, ignoring NaN values.
• gnansumkbn( N, x, stride ): calculate the sum of strided array elements, ignoring NaN values and using an improved Kahan–Babuška algorithm.
• gnansumkbn2( N, x, stride ): calculate the sum of strided array elements, ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.
• gnansumors( N, x, stride ): calculate the sum of strided array elements, ignoring NaN values and using ordinary recursive summation.
• gnansumpw( N, x, stride ): calculate the sum of strided array elements, ignoring NaN values and using pairwise summation.
• grev( N, x, stride ): reverse a strided array in-place.
• 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, stride ): sort a strided array using heapsort.
• gsortins( N, order, x, stride ): sort a strided array using insertion sort.
• gsortsh( N, order, x, stride ): sort a strided array using Shellsort.
• gsum( N, x, stride ): calculate the sum of strided array elements.
• gsumkbn( N, x, stride ): calculate the sum of strided array elements using an improved Kahan–Babuška algorithm.
• gsumkbn2( N, x, stride ): calculate the sum of strided array elements using a second-order iterative Kahan–Babuška algorithm.
• gsumors( N, x, stride ): calculate the sum of strided array elements using ordinary recursive summation.
• gsumpw( N, x, stride ): calculate the sum of strided array elements using pairwise summation.
• sapx( N, alpha, x, stride ): add a constant to each element in a single-precision floating-point strided array.
• sapxsum( N, alpha, x, stride ): add a constant to each single-precision floating-point strided array element and compute the sum.
• sapxsumkbn( N, alpha, x, stride ): add a 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, stride ): add a 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, stride ): add a constant to each single-precision floating-point strided array element and compute the sum using ordinary recursive summation.
• sapxsumpw( N, alpha, x, stride ): add a constant to each single-precision floating-point strided array element and compute the sum using pairwise summation.
• sasumpw( N, x, stride ): calculate the sum of absolute values (L1 norm) of single-precision floating-point strided array elements using pairwise summation.
• 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, stride ): add a constant to each single-precision floating-point strided array element and compute the sum using extended accumulation.
• sdsapxsumpw( N, alpha, x, stride ): add a constant to each single-precision floating-point strided array element and compute the sum using pairwise summation with extended accumulation.
• sdsnansum( N, x, stride ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using extended accumulation.
• sdsnansumpw( N, x, stride ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using pairwise summation with extended accumulation.
• sdssum( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using extended accumulation.
• sdssumpw( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using pairwise summation with extended accumulation.
• sfill( N, alpha, x, stride ): fill a single-precision floating-point strided array with a specified scalar constant.
• snansum( N, x, stride ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values.
• snansumkbn( N, x, stride ): 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, stride ): 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, stride ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using ordinary recursive summation.
• snansumpw( N, x, stride ): calculate the sum of single-precision floating-point strided array elements, ignoring NaN values and using pairwise summation.
• srev( N, x, stride ): 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, stride ): calculate the sum of single-precision floating-point strided array elements.
• ssumkbn( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using an improved Kahan–Babuška algorithm.
• ssumkbn2( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using a second-order iterative Kahan–Babuška algorithm.
• ssumors( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using ordinary recursive summation.
• ssumpw( N, x, stride ): calculate the sum of single-precision floating-point strided array elements using pairwise summation.

Examples

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

console.log( objectKeys( ns ) );