From ffdc0433d3a751ed5ccd3f901b2c1be18e992769 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Sun, 29 Mar 2026 05:47:39 +0000 Subject: [PATCH] feat: update `blas/ext/base/ndarray` TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../ext/base/ndarray/docs/types/index.d.ts | 1400 +++++++++++++++-- 1 file changed, 1248 insertions(+), 152 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts index 71610fd8a513..2a0b4ce1737d 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts @@ -21,27 +21,75 @@ /* eslint-disable max-lines */ import csum = require( '@stdlib/blas/ext/base/ndarray/csum' ); +import csumkbn = require( '@stdlib/blas/ext/base/ndarray/csumkbn' ); +import dcircshift = require( '@stdlib/blas/ext/base/ndarray/dcircshift' ); import dcusum = require( '@stdlib/blas/ext/base/ndarray/dcusum' ); +import dcusumkbn = require( '@stdlib/blas/ext/base/ndarray/dcusumkbn' ); +import dcusumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dcusumkbn2' ); +import dcusumors = require( '@stdlib/blas/ext/base/ndarray/dcusumors' ); +import dcusumpw = require( '@stdlib/blas/ext/base/ndarray/dcusumpw' ); import dindexOf = require( '@stdlib/blas/ext/base/ndarray/dindex-of' ); import dlastIndexOf = require( '@stdlib/blas/ext/base/ndarray/dlast-index-of' ); import dlinspace = require( '@stdlib/blas/ext/base/ndarray/dlinspace' ); +import dnansum = require( '@stdlib/blas/ext/base/ndarray/dnansum' ); +import dnansumkbn = require( '@stdlib/blas/ext/base/ndarray/dnansumkbn' ); +import dnansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dnansumkbn2' ); +import dnansumors = require( '@stdlib/blas/ext/base/ndarray/dnansumors' ); +import dnansumpw = require( '@stdlib/blas/ext/base/ndarray/dnansumpw' ); import dsorthp = require( '@stdlib/blas/ext/base/ndarray/dsorthp' ); +import dsortins = require( '@stdlib/blas/ext/base/ndarray/dsortins' ); +import dsortsh = require( '@stdlib/blas/ext/base/ndarray/dsortsh' ); import dsum = require( '@stdlib/blas/ext/base/ndarray/dsum' ); +import dsumkbn = require( '@stdlib/blas/ext/base/ndarray/dsumkbn' ); +import dsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dsumkbn2' ); +import dsumors = require( '@stdlib/blas/ext/base/ndarray/dsumors' ); +import dsumpw = require( '@stdlib/blas/ext/base/ndarray/dsumpw' ); +import gcircshift = require( '@stdlib/blas/ext/base/ndarray/gcircshift' ); import gcusum = require( '@stdlib/blas/ext/base/ndarray/gcusum' ); +import gcusumkbn = require( '@stdlib/blas/ext/base/ndarray/gcusumkbn' ); +import gcusumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gcusumkbn2' ); +import gcusumors = require( '@stdlib/blas/ext/base/ndarray/gcusumors' ); +import gcusumpw = require( '@stdlib/blas/ext/base/ndarray/gcusumpw' ); import gfindIndex = require( '@stdlib/blas/ext/base/ndarray/gfind-index' ); import gfindLastIndex = require( '@stdlib/blas/ext/base/ndarray/gfind-last-index' ); import gindexOf = require( '@stdlib/blas/ext/base/ndarray/gindex-of' ); +import gjoin = require( '@stdlib/blas/ext/base/ndarray/gjoin' ); +import gjoinBetween = require( '@stdlib/blas/ext/base/ndarray/gjoin-between' ); import glastIndexOf = require( '@stdlib/blas/ext/base/ndarray/glast-index-of' ); import glinspace = require( '@stdlib/blas/ext/base/ndarray/glinspace' ); +import gnansum = require( '@stdlib/blas/ext/base/ndarray/gnansum' ); +import gnansumkbn = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn' ); +import gnansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn2' ); +import gnansumors = require( '@stdlib/blas/ext/base/ndarray/gnansumors' ); +import gnansumpw = require( '@stdlib/blas/ext/base/ndarray/gnansumpw' ); +import gsort = require( '@stdlib/blas/ext/base/ndarray/gsort' ); import gsorthp = require( '@stdlib/blas/ext/base/ndarray/gsorthp' ); import gsum = require( '@stdlib/blas/ext/base/ndarray/gsum' ); +import gsumkbn = require( '@stdlib/blas/ext/base/ndarray/gsumkbn' ); +import gsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gsumkbn2' ); +import gsumors = require( '@stdlib/blas/ext/base/ndarray/gsumors' ); +import gsumpw = require( '@stdlib/blas/ext/base/ndarray/gsumpw' ); +import scircshift = require( '@stdlib/blas/ext/base/ndarray/scircshift' ); import scusum = require( '@stdlib/blas/ext/base/ndarray/scusum' ); +import scusumkbn = require( '@stdlib/blas/ext/base/ndarray/scusumkbn' ); +import scusumkbn2 = require( '@stdlib/blas/ext/base/ndarray/scusumkbn2' ); +import scusumors = require( '@stdlib/blas/ext/base/ndarray/scusumors' ); import sindexOf = require( '@stdlib/blas/ext/base/ndarray/sindex-of' ); import slastIndexOf = require( '@stdlib/blas/ext/base/ndarray/slast-index-of' ); import slinspace = require( '@stdlib/blas/ext/base/ndarray/slinspace' ); +import snansum = require( '@stdlib/blas/ext/base/ndarray/snansum' ); +import snansumkbn = require( '@stdlib/blas/ext/base/ndarray/snansumkbn' ); +import snansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/snansumkbn2' ); +import snansumors = require( '@stdlib/blas/ext/base/ndarray/snansumors' ); +import snansumpw = require( '@stdlib/blas/ext/base/ndarray/snansumpw' ); import ssorthp = require( '@stdlib/blas/ext/base/ndarray/ssorthp' ); import ssum = require( '@stdlib/blas/ext/base/ndarray/ssum' ); +import ssumkbn = require( '@stdlib/blas/ext/base/ndarray/ssumkbn' ); +import ssumkbn2 = require( '@stdlib/blas/ext/base/ndarray/ssumkbn2' ); +import ssumors = require( '@stdlib/blas/ext/base/ndarray/ssumors' ); +import ssumpw = require( '@stdlib/blas/ext/base/ndarray/ssumpw' ); import zsum = require( '@stdlib/blas/ext/base/ndarray/zsum' ); +import zsumkbn = require( '@stdlib/blas/ext/base/ndarray/zsumkbn' ); /** * Interface describing the `ndarray` namespace. @@ -65,6 +113,47 @@ interface Namespace { */ csum: typeof csum; + /** + * Computes the sum of all elements in a one-dimensional single-precision complex floating-point ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Complex64Array( [ 1.0, -2.0, 2.0, 3.0 ] ); + * var x = new ndarray( 'complex64', xbuf, [ 2 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.csumkbn( [ x ] ); + * // returns [ 3.0, 1.0 ] + */ + csumkbn: typeof csumkbn; + + /** + * Circularly shifts the elements of a one-dimensional double-precision floating-point ndarray by a specified number of positions. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift + * @returns input ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var k = scalar2ndarray( 2, { + * 'dtype': 'generic' + * }); + * + * var out = ns.dcircshift( [ x, k ] ); + * // returns [ 4.0, 5.0, 1.0, 2.0, 3.0 ] + */ + dcircshift: typeof dcircshift; + /** * Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray. * @@ -92,6 +181,118 @@ interface Namespace { */ dcusum: typeof dcusum; + /** + * Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float64', 'row-major' ); + * + * var v = ns.dcusumkbn( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + */ + dcusumkbn: typeof dcusumkbn; + + /** + * Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float64', 'row-major' ); + * + * var v = ns.dcusumkbn2( [ x, y, initial ] ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * + * var bool = ( v === y ); + * // returns true + */ + dcusumkbn2: typeof dcusumkbn2; + + /** + * Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float64', 'row-major' ); + * + * var v = ns.dcusumors( [ x, y, initial ] ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * + * var bool = ( v === y ); + * // returns true + */ + dcusumors: typeof dcusumors; + + /** + * Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float64', 'row-major' ); + * + * var v = ns.dcusumpw( [ x, y, initial ] ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * + * var bool = ( v === y ); + * // returns true + */ + dcusumpw: typeof dcusumpw; + /** * Returns the first index of a search element in a one-dimensional double-precision floating-point ndarray. * @@ -187,38 +388,25 @@ interface Namespace { dlinspace: typeof dlinspace; /** - * Sorts a one-dimensional double-precision floating-point ndarray using heapsort. - * - * ## Notes - * - * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring NaN values. * - * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order - * @returns input ndarray + * @param arrays - array-like object containing an input ndarray + * @returns sum * * @example * var Float64Array = require( '@stdlib/array/float64' ); - * var ndarray2array = require( '@stdlib/ndarray/to-array' ); - * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var ord = scalar2ndarray( 1.0, { - * 'dtype': 'generic' - * }); - * - * var out = ns.dsorthp( [ x, ord ] ); - * // returns - * - * var arr = ndarray2array( out ); - * // returns [ -4.0, -2.0, 1.0, 3.0 ] + * var v = ns.dnansum( [ x ] ); + * // returns 1.0 */ - dsorthp: typeof dsorthp; + dnansum: typeof dnansum; /** - * Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray. + * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm. * * @param arrays - array-like object containing an input ndarray * @returns sum @@ -227,128 +415,558 @@ interface Namespace { * var Float64Array = require( '@stdlib/array/float64' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.dsum( [ x ] ); - * // returns 10.0 + * var v = ns.dnansumkbn( [ x ] ); + * // returns 1.0 */ - dsum: typeof dsum; + dnansumkbn: typeof dnansumkbn; /** - * Computes the cumulative sum of a one-dimensional ndarray. + * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm. * - * @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum - * @returns output ndarray + * @param arrays - array-like object containing an input ndarray + * @returns sum * * @example - * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); - * - * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; - * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); - * - * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); - * - * var v = ns.gcusum( [ x, y, initial ] ); - * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var bool = ( v === y ); - * // returns true + * var v = ns.dnansumkbn2( [ x ] ); + * // returns 1.0 */ - gcusum: typeof gcusum; + dnansumkbn2: typeof dnansumkbn2; /** - * Returns the index of the first element in a one-dimensional ndarray which passes a test implemented by a predicate function. - * - * ## Notes - * - * - If no element passes a test implemented by a predicate function, the function returns `-1`. + * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation. * * @param arrays - array-like object containing an input ndarray - * @param clbk - predicate function - * @param thisArg - predicate function execution context - * @returns index + * @returns sum * * @example + * var Float64Array = require( '@stdlib/array/float64' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * function clbk( v ) { - * return v % 2.0 === 0.0; - * } - * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.gfindIndex( [ x ], clbk ); - * // returns 2 + * var v = ns.dnansumors( [ x ] ); + * // returns 1.0 */ - gfindIndex: typeof gfindIndex; + dnansumors: typeof dnansumors; /** - * Returns the index of the last element in a one-dimensional ndarray which passes a test implemented by a predicate function. - * - * ## Notes - * - * - If no element passes a test implemented by a predicate function, the function returns `-1`. + * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using pairwise summation. * * @param arrays - array-like object containing an input ndarray - * @param clbk - predicate function - * @param thisArg - predicate execution context - * @returns index + * @returns sum * * @example + * var Float64Array = require( '@stdlib/array/float64' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * function clbk( v ) { - * return v % 2.0 === 0.0; - * } - * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.gfindLastIndex( [ x ], clbk ); - * // returns 3 + * var v = ns.dnansumpw( [ x ] ); + * // returns 1.0 */ - gfindLastIndex: typeof gfindLastIndex; + dnansumpw: typeof dnansumpw; /** - * Returns the first index of a search element in a one-dimensional ndarray. + * Sorts a one-dimensional double-precision floating-point ndarray using heapsort. * - * @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching - * @returns index + * ## Notes + * + * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order + * @returns input ndarray * * @example - * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var searchElement = scalar2ndarray( 2.0, { - * 'dtype': 'generic' + * var ord = scalar2ndarray( 1.0, { + * 'dtype': 'generic' * }); * - * var fromIndex = scalar2ndarray( 0, { - * 'dtype': 'generic' - * }); + * var out = ns.dsorthp( [ x, ord ] ); + * // returns * - * var v = ns.gindexOf( [ x, searchElement, fromIndex ] ); - * // returns 3 + * var arr = ndarray2array( out ); + * // returns [ -4.0, -2.0, 1.0, 3.0 ] */ - gindexOf: typeof gindexOf; + dsorthp: typeof dsorthp; /** - * Returns the last index of a search element in a one-dimensional ndarray. + * Sorts a one-dimensional double-precision floating-point ndarray using insertion sort. * - * @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching - * @returns index + * ## Notes + * + * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order + * @returns input ndarray * * @example - * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ord = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.dsortins( [ x, ord ] ); + * // returns + * + * var arr = ndarray2array( out ); + * // returns [ -4.0, -2.0, 1.0, 3.0 ] + */ + dsortins: typeof dsortins; + + /** + * Sorts a one-dimensional double-precision floating-point ndarray using Shellsort. + * + * ## Notes + * + * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order + * @returns input ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ord = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.dsortsh( [ x, ord ] ); + * // returns + * + * var arr = ndarray2array( out ); + * // returns [ -4.0, -2.0, 1.0, 3.0 ] + */ + dsortsh: typeof dsortsh; + + /** + * Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dsum( [ x ] ); + * // returns 10.0 + */ + dsum: typeof dsum; + + /** + * Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dsumkbn( [ x ] ); + * // returns 1.0 + */ + dsumkbn: typeof dsumkbn; + + /** + * Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dsumkbn2( [ x ] ); + * // returns 1.0 + */ + dsumkbn2: typeof dsumkbn2; + + /** + * Computes the sum of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dsumors( [ x ] ); + * // returns 10.0 + */ + dsumors: typeof dsumors; + + /** + * Computes the sum of a one-dimensional double-precision floating-point ndarray using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dsumpw( [ x ] ); + * // returns 10.0 + */ + dsumpw: typeof dsumpw; + + /** + * Circularly shifts the elements of a one-dimensional ndarray by a specified number of positions. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift + * @returns input ndarray + * + * @example + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 2.0, 3.0, 4.0, 5.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var k = scalar2ndarray( 2, { + * 'dtype': 'generic' + * }); + * + * var out = ns.gcircshift( [ x, k ] ); + * // returns [ 4.0, 5.0, 1.0, 2.0, 3.0 ] + */ + gcircshift: typeof gcircshift; + + /** + * Computes the cumulative sum of a one-dimensional ndarray. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; + * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); + * + * var v = ns.gcusum( [ x, y, initial ] ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * + * var bool = ( v === y ); + * // returns true + */ + gcusum: typeof gcusum; + + /** + * Computes the cumulative sum of a one-dimensional ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; + * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); + * + * var v = ns.gcusumkbn( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + */ + gcusumkbn: typeof gcusumkbn; + + /** + * Computes the cumulative sum of a one-dimensional ndarray using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; + * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); + * + * var v = ns.gcusumkbn2( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + */ + gcusumkbn2: typeof gcusumkbn2; + + /** + * Computes the cumulative sum of a one-dimensional ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; + * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); + * + * var v = ns.gcusumors( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + */ + gcusumors: typeof gcusumors; + + /** + * Computes the cumulative sum of a one-dimensional ndarray using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray + * + * @example + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = [ 0.0, 0.0, 0.0, 0.0 ]; + * var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'generic', 'row-major' ); + * + * var v = ns.gcusumpw( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + */ + gcusumpw: typeof gcusumpw; + + /** + * Returns the index of the first element in a one-dimensional ndarray which passes a test implemented by a predicate function. + * + * ## Notes + * + * - If no element passes a test implemented by a predicate function, the function returns `-1`. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - predicate function + * @param thisArg - predicate function execution context + * @returns index + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( v ) { + * return v % 2.0 === 0.0; + * } + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gfindIndex( [ x ], clbk ); + * // returns 2 + */ + gfindIndex: typeof gfindIndex; + + /** + * Returns the index of the last element in a one-dimensional ndarray which passes a test implemented by a predicate function. + * + * ## Notes + * + * - If no element passes a test implemented by a predicate function, the function returns `-1`. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - predicate function + * @param thisArg - predicate execution context + * @returns index + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( v ) { + * return v % 2.0 === 0.0; + * } + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gfindLastIndex( [ x ], clbk ); + * // returns 3 + */ + gfindLastIndex: typeof gfindLastIndex; + + /** + * Returns the first index of a search element in a one-dimensional ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching + * @returns index + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var searchElement = scalar2ndarray( 2.0, { + * 'dtype': 'generic' + * }); + * + * var fromIndex = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var v = ns.gindexOf( [ x, searchElement, fromIndex ] ); + * // returns 3 + */ + gindexOf: typeof gindexOf; + + /** + * Returns a string created by joining one-dimensional ndarray elements using a specified separator. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray containing a separator + * @returns joined string + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var separator = scalar2ndarray( ',', { + * 'dtype': 'generic' + * }); + * + * var v = ns.gjoin( [ x, separator ] ); + * // returns '1,3,4,2' + */ + gjoin: typeof gjoin; + + /** + * Returns a string by joining one-dimensional ndarray elements using a specified separator for each pair of consecutive elements. + * + * @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing a prefix string, a zero-dimensional ndarray containing a suffix string, and a one-dimensional ndarray containing separator strings + * @returns joined string + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var xbuf = [ 1, 2, 3, 4 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var prefix = scalar2ndarray( 'op: ', { + * 'dtype': 'generic' + * }); + * + * var suffix = scalar2ndarray( '', { + * 'dtype': 'generic' + * }); + * + * var sbuf = [ ' + ', ' - ', ' != ' ]; + * var separators = new ndarray( 'generic', sbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gjoinBetween( [ x, prefix, suffix, separators ] ); + * // returns 'op: 1 + 2 - 3 != 4' + */ + gjoinBetween: typeof gjoinBetween; + + /** + * Returns the last index of a search element in a one-dimensional ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching + * @returns index + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); * * var xbuf = [ 1.0, 2.0, 4.0, 2.0 ]; @@ -365,106 +983,401 @@ interface Namespace { * var v = ns.glastIndexOf( [ x, searchElement, fromIndex ] ); * // returns 3 */ - glastIndexOf: typeof glastIndexOf; + glastIndexOf: typeof glastIndexOf; + + /** + * Fills a one-dimensional ndarray with linearly spaced values over a specified interval. + * + * ## Notes + * + * - The function expects the following ndarrays in order: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying the start of the interval. + * - a zero-dimensional ndarray specifying the end of the interval. + * - a zero-dimensional ndarray specifying whether to include the end of the interval when writing values to the input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var xbuf = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 6 ], [ 1 ], 0, 'row-major' ); + * + * var start = scalar2ndarray( 0.0, { + * 'dtype': 'generic' + * }); + * + * var stop = scalar2ndarray( 100.0, { + * 'dtype': 'generic' + * }); + * + * var endpoint = scalar2ndarray( true, { + * 'dtype': 'bool' + * }); + * + * var out = ns.glinspace( [ x, start, stop, endpoint ] ); + * // returns + * + * var arr = ndarray2array( out ); + * // returns [ 0.0, 20.0, 40.0, 60.0, 80.0, 100.0 ] + */ + glinspace: typeof glinspace; + + /** + * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gnansum( [ x ] ); + * // returns 1.0 + */ + gnansum: typeof gnansum; + + /** + * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gnansumkbn( [ x ] ); + * // returns 1.0 + */ + gnansumkbn: typeof gnansumkbn; + + /** + * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gnansumkbn2( [ x ] ); + * // returns 1.0 + */ + gnansumkbn2: typeof gnansumkbn2; + + /** + * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gnansumors( [ x ] ); + * // returns 1.0 + */ + gnansumors: typeof gnansumors; + + /** + * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gnansumpw( [ x ] ); + * // returns 1.0 + */ + gnansumpw: typeof gnansumpw; + + /** + * Sorts a one-dimensional ndarray. + * + * ## Notes + * + * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order + * @returns input ndarray + * + * @example + * var array = require( '@stdlib/ndarray/array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var x = array( [ 1.0, -2.0, 3.0, -4.0 ], { + * 'dtype': 'generic' + * }); + * // returns [ 1.0, -2.0, 3.0, -4.0 ] + * + * var ord = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * // returns [ 1.0 ] + * + * var out = ns.gsort( [ x, ord ] ); + * // returns [ -4.0, -2.0, 1.0, 3.0 ] + */ + gsort: typeof gsort; + + /** + * Sorts a one-dimensional ndarray using heapsort. + * + * ## Notes + * + * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order + * @returns input ndarray + * + * @example + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 3.0, -4.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ord = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.gsorthp( [ x, ord ] ); + * // returns + * + * var arr = ndarray2array( out ); + * // returns [ -4.0, -2.0, 1.0, 3.0 ] + */ + gsorthp: typeof gsorthp; + + /** + * Computes the sum of all elements in a one-dimensional ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gsum( [ x ] ); + * // returns 10.0 + */ + gsum: typeof gsum; + + /** + * Computes the sum of all elements in a one-dimensional ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gsumkbn( [ x ] ); + * // returns 10.0 + */ + gsumkbn: typeof gsumkbn; + + /** + * Computes the sum of all elements in a one-dimensional ndarray using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gsumkbn2( [ x ] ); + * // returns 10.0 + */ + gsumkbn2: typeof gsumkbn2; + + /** + * Computes the sum of all elements in a one-dimensional ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gsumors( [ x ] ); + * // returns 10.0 + */ + gsumors: typeof gsumors; + + /** + * Computes the sum of all elements in a one-dimensional ndarray using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.gsumpw( [ x ] ); + * // returns 10.0 + */ + gsumpw: typeof gsumpw; /** - * Fills a one-dimensional ndarray with linearly spaced values over a specified interval. - * - * ## Notes - * - * - The function expects the following ndarrays in order: - * - * - a one-dimensional input ndarray. - * - a zero-dimensional ndarray specifying the start of the interval. - * - a zero-dimensional ndarray specifying the end of the interval. - * - a zero-dimensional ndarray specifying whether to include the end of the interval when writing values to the input ndarray. + * Circularly shifts the elements of a one-dimensional single-precision floating-point ndarray by a specified number of positions. * - * @param arrays - array-like object containing ndarrays + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift * @returns input ndarray * * @example - * var ndarray = require( '@stdlib/ndarray/base/ctor' ); - * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var Float32Array = require( '@stdlib/array/float32' ); * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 6 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); * - * var start = scalar2ndarray( 0.0, { + * var k = scalar2ndarray( 2, { * 'dtype': 'generic' * }); * - * var stop = scalar2ndarray( 100.0, { - * 'dtype': 'generic' - * }); + * var out = ns.scircshift( [ x, k ] ); + * // returns [ 4.0, 5.0, 1.0, 2.0, 3.0 ] + */ + scircshift: typeof scircshift; + + /** + * Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray. * - * var endpoint = scalar2ndarray( true, { - * 'dtype': 'bool' - * }); + * @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum + * @returns output ndarray * - * var out = ns.glinspace( [ x, start, stop, endpoint ] ); - * // returns + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var arr = ndarray2array( out ); - * // returns [ 0.0, 20.0, 40.0, 60.0, 80.0, 100.0 ] + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float32', 'row-major' ); + * + * var v = ns.scusum( [ x, y, initial ] ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * + * var bool = ( v === y ); + * // returns true */ - glinspace: typeof glinspace; + scusum: typeof scusum; /** - * Sorts a one-dimensional ndarray using heapsort. + * Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using an improved Kahan–Babuška algorithm. * - * ## Notes - * - * - When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged. - * - * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order - * @returns input ndarray + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray * * @example + * var Float32Array = require( '@stdlib/array/float32' ); * var ndarray2array = require( '@stdlib/ndarray/to-array' ); - * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 1.0, -2.0, 3.0, -4.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var ord = scalar2ndarray( 1.0, { - * 'dtype': 'generic' - * }); + * var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var out = ns.gsorthp( [ x, ord ] ); + * var initial = scalar2ndarray( 0.0, 'float32', 'row-major' ); + * + * var v = ns.scusumkbn( [ x, y, initial ] ); * // returns * - * var arr = ndarray2array( out ); - * // returns [ -4.0, -2.0, 1.0, 3.0 ] + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] */ - gsorthp: typeof gsorthp; + scusumkbn: typeof scusumkbn; /** - * Computes the sum of all elements in a one-dimensional ndarray. + * Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm. * - * @param arrays - array-like object containing an input ndarray - * @returns sum + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum + * @returns output ndarray * * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); + * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; - * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.gsum( [ x ] ); - * // returns 10.0 + * var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var initial = scalar2ndarray( 0.0, 'float32', 'row-major' ); + * + * var v = ns.scusumkbn2( [ x, y, initial ] ); + * // returns + * + * var bool = ( v === y ); + * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] */ - gsum: typeof gsum; + scusumkbn2: typeof scusumkbn2; /** - * Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray. + * Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation. * - * @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum + * @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum * @returns output ndarray * * @example * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray2array = require( '@stdlib/ndarray/to-array' ); * var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * @@ -476,13 +1389,16 @@ interface Namespace { * * var initial = scalar2ndarray( 0.0, 'float32', 'row-major' ); * - * var v = ns.scusum( [ x, y, initial ] ); - * // returns [ 1.0, 4.0, 8.0, 10.0 ] + * var v = ns.scusumors( [ x, y, initial ] ); + * // returns * * var bool = ( v === y ); * // returns true + * + * var arr = ndarray2array( v ); + * // returns [ 1.0, 4.0, 8.0, 10.0 ] */ - scusum: typeof scusum; + scusumors: typeof scusumors; /** * Returns the first index of a search element in a one-dimensional single-precision floating-point ndarray. @@ -582,6 +1498,96 @@ interface Namespace { */ slinspace: typeof slinspace; + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snansum( [ x ] ); + * // returns 1.0 + */ + snansum: typeof snansum; + + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snansumkbn( [ x ] ); + * // returns 1.0 + */ + snansumkbn: typeof snansumkbn; + + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snansumkbn2( [ x ] ); + * // returns 1.0 + */ + snansumkbn2: typeof snansumkbn2; + + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snansumors( [ x ] ); + * // returns 1.0 + */ + snansumors: typeof snansumors; + + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snansumpw( [ x ] ); + * // returns 1.0 + */ + snansumpw: typeof snansumpw; + /** * Sorts a one-dimensional single-precision floating-point ndarray using heapsort. * @@ -631,6 +1637,78 @@ interface Namespace { */ ssum: typeof ssum; + /** + * Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.ssumkbn( [ x ] ); + * // returns 10.0 + */ + ssumkbn: typeof ssumkbn; + + /** + * Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.ssumkbn2( [ x ] ); + * // returns 10.0 + */ + ssumkbn2: typeof ssumkbn2; + + /** + * Computes the sum of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.ssumors( [ x ] ); + * // returns 10.0 + */ + ssumors: typeof ssumors; + + /** + * Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using pairwise summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.ssumpw( [ x ] ); + * // returns 10.0 + */ + ssumpw: typeof ssumpw; + /** * Computes the sum of all elements in a one-dimensional double-precision complex floating-point ndarray. * @@ -648,6 +1726,24 @@ interface Namespace { * // returns [ 5.0, 5.0 ] */ zsum: typeof zsum; + + /** + * Computes the sum of all elements in a one-dimensional double-precision complex floating-point ndarray using an improved Kahan–Babuška algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns sum + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Complex128Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'complex128', xbuf, [ 2 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.zsumkbn( [ x ] ); + * // returns [ 5.0, 5.0 ] + */ + zsumkbn: typeof zsumkbn; } /**