diff --git a/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts index b20dd96b7f74..bdcc5abe9ff2 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts @@ -25,6 +25,7 @@ import cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' ); import coneTo = require( '@stdlib/blas/ext/base/cone-to' ); import csum = require( '@stdlib/blas/ext/base/csum' ); import csumkbn = require( '@stdlib/blas/ext/base/csumkbn' ); +import cunitspace = require( '@stdlib/blas/ext/base/cunitspace' ); import czeroTo = require( '@stdlib/blas/ext/base/czero-to' ); import dapx = require( '@stdlib/blas/ext/base/dapx' ); import dapxsum = require( '@stdlib/blas/ext/base/dapxsum' ); @@ -39,6 +40,7 @@ import dcusumkbn = require( '@stdlib/blas/ext/base/dcusumkbn' ); import dcusumkbn2 = require( '@stdlib/blas/ext/base/dcusumkbn2' ); import dcusumors = require( '@stdlib/blas/ext/base/dcusumors' ); import dcusumpw = require( '@stdlib/blas/ext/base/dcusumpw' ); +import ddiff = require( '@stdlib/blas/ext/base/ddiff' ); import dfill = require( '@stdlib/blas/ext/base/dfill' ); import dindexOf = require( '@stdlib/blas/ext/base/dindex-of' ); import dindexOfRow = require( '@stdlib/blas/ext/base/dindex-of-row' ); @@ -46,6 +48,7 @@ import dlastIndexOf = require( '@stdlib/blas/ext/base/dlast-index-of' ); import dlinspace = require( '@stdlib/blas/ext/base/dlinspace' ); import dnanasum = require( '@stdlib/blas/ext/base/dnanasum' ); import dnanasumors = require( '@stdlib/blas/ext/base/dnanasumors' ); +import dnancount = require( '@stdlib/blas/ext/base/dnancount' ); import dnancusumkbn = require( '@stdlib/blas/ext/base/dnancusumkbn' ); import dnannsum = require( '@stdlib/blas/ext/base/dnannsum' ); import dnannsumkbn = require( '@stdlib/blas/ext/base/dnannsumkbn' ); @@ -84,6 +87,8 @@ import dsumkbn = require( '@stdlib/blas/ext/base/dsumkbn' ); import dsumkbn2 = require( '@stdlib/blas/ext/base/dsumkbn2' ); import dsumors = require( '@stdlib/blas/ext/base/dsumors' ); import dsumpw = require( '@stdlib/blas/ext/base/dsumpw' ); +import dunitspace = require( '@stdlib/blas/ext/base/dunitspace' ); +import dvander = require( '@stdlib/blas/ext/base/dvander' ); import dzeroTo = require( '@stdlib/blas/ext/base/dzero-to' ); import gapx = require( '@stdlib/blas/ext/base/gapx' ); import gapxsum = require( '@stdlib/blas/ext/base/gapxsum' ); @@ -110,6 +115,7 @@ import gjoin = require( '@stdlib/blas/ext/base/gjoin' ); import gjoinBetween = require( '@stdlib/blas/ext/base/gjoin-between' ); import glastIndexOf = require( '@stdlib/blas/ext/base/glast-index-of' ); import glinspace = require( '@stdlib/blas/ext/base/glinspace' ); +import gnancount = require( '@stdlib/blas/ext/base/gnancount' ); import gnannsumkbn = require( '@stdlib/blas/ext/base/gnannsumkbn' ); import gnannsumpw = require( '@stdlib/blas/ext/base/gnannsumpw' ); import gnansum = require( '@stdlib/blas/ext/base/gnansum' ); @@ -132,7 +138,9 @@ import gsumkbn = require( '@stdlib/blas/ext/base/gsumkbn' ); import gsumkbn2 = require( '@stdlib/blas/ext/base/gsumkbn2' ); import gsumors = require( '@stdlib/blas/ext/base/gsumors' ); import gsumpw = require( '@stdlib/blas/ext/base/gsumpw' ); +import gunitspace = require( '@stdlib/blas/ext/base/gunitspace' ); import gvander = require( '@stdlib/blas/ext/base/gvander' ); +import gwhere = require( '@stdlib/blas/ext/base/gwhere' ); import gzeroTo = require( '@stdlib/blas/ext/base/gzero-to' ); import ndarray = require( '@stdlib/blas/ext/base/ndarray' ); import sapx = require( '@stdlib/blas/ext/base/sapx' ); @@ -148,6 +156,7 @@ import scusumkbn = require( '@stdlib/blas/ext/base/scusumkbn' ); import scusumkbn2 = require( '@stdlib/blas/ext/base/scusumkbn2' ); import scusumors = require( '@stdlib/blas/ext/base/scusumors' ); import scusumpw = require( '@stdlib/blas/ext/base/scusumpw' ); +import sdiff = require( '@stdlib/blas/ext/base/sdiff' ); import sdsapxsum = require( '@stdlib/blas/ext/base/sdsapxsum' ); import sdsapxsumpw = require( '@stdlib/blas/ext/base/sdsapxsumpw' ); import sdsnansum = require( '@stdlib/blas/ext/base/sdsnansum' ); @@ -159,6 +168,7 @@ import sindexOf = require( '@stdlib/blas/ext/base/sindex-of' ); import sindexOfRow = require( '@stdlib/blas/ext/base/sindex-of-row' ); import slastIndexOf = require( '@stdlib/blas/ext/base/slast-index-of' ); import slinspace = require( '@stdlib/blas/ext/base/slinspace' ); +import snancount = require( '@stdlib/blas/ext/base/snancount' ); import snansum = require( '@stdlib/blas/ext/base/snansum' ); import snansumkbn = require( '@stdlib/blas/ext/base/snansumkbn' ); import snansumkbn2 = require( '@stdlib/blas/ext/base/snansumkbn2' ); @@ -166,6 +176,7 @@ import snansumors = require( '@stdlib/blas/ext/base/snansumors' ); import snansumpw = require( '@stdlib/blas/ext/base/snansumpw' ); import soneTo = require( '@stdlib/blas/ext/base/sone-to' ); import srev = require( '@stdlib/blas/ext/base/srev' ); +import ssort = require( '@stdlib/blas/ext/base/ssort' ); import ssort2hp = require( '@stdlib/blas/ext/base/ssort2hp' ); import ssort2ins = require( '@stdlib/blas/ext/base/ssort2ins' ); import ssort2sh = require( '@stdlib/blas/ext/base/ssort2sh' ); @@ -177,13 +188,17 @@ import ssumkbn = require( '@stdlib/blas/ext/base/ssumkbn' ); import ssumkbn2 = require( '@stdlib/blas/ext/base/ssumkbn2' ); import ssumors = require( '@stdlib/blas/ext/base/ssumors' ); import ssumpw = require( '@stdlib/blas/ext/base/ssumpw' ); +import sunitspace = require( '@stdlib/blas/ext/base/sunitspace' ); +import svander = require( '@stdlib/blas/ext/base/svander' ); import szeroTo = require( '@stdlib/blas/ext/base/szero-to' ); import wasm = require( '@stdlib/blas/ext/base/wasm' ); import zfill = require( '@stdlib/blas/ext/base/zfill' ); import zindexOfRow = require( '@stdlib/blas/ext/base/zindex-of-row' ); +import znancount = require( '@stdlib/blas/ext/base/znancount' ); import zoneTo = require( '@stdlib/blas/ext/base/zone-to' ); import zsum = require( '@stdlib/blas/ext/base/zsum' ); import zsumkbn = require( '@stdlib/blas/ext/base/zsumkbn' ); +import zunitspace = require( '@stdlib/blas/ext/base/zunitspace' ); import zzeroTo = require( '@stdlib/blas/ext/base/zzero-to' ); /** @@ -344,6 +359,35 @@ interface Namespace { */ csumkbn: typeof csumkbn; + /** + * Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. + * + * @param N - number of indexed elements + * @param start - starting value + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.cunitspace( x.length, new Complex64( 3.0, 0.0 ), x, 1 ); + * // x => [ 3.0, 0.0, 4.0, 0.0, 5.0, 0.0, 6.0, 0.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.cunitspace.ndarray( x.length, new Complex64( 3.0, 0.0 ), x, 1, 0 ); + * // x => [ 3.0, 0.0, 4.0, 0.0, 5.0, 0.0, 6.0, 0.0 ] + */ + cunitspace: typeof cunitspace; + /** * Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from zero. * @@ -740,6 +784,60 @@ interface Namespace { */ dcusumpw: typeof dcusumpw; + /** + * Calculates the k-th discrete forward difference of a double-precision floating-point strided array. + * + * ## Notes + * + * - The `out` array must have `N + N1 + N2 - k` elements. + * - The `workspace` array must have `N + N1 + N2 - 1` elements. + * + * @param N - number of indexed elements + * @param k - number of times to recursively compute differences + * @param x - input array + * @param strideX - stride length for `x` + * @param N1 - number of indexed elements for `prepend` + * @param prepend - prepend array + * @param strideP - stride length for `prepend` + * @param N2 - number of indexed elements for `append` + * @param append - append array + * @param strideA - stride length for `append` + * @param out - output array + * @param strideOut - stride length for `out` + * @param workspace - workspace array + * @param strideW - stride length for `workspace` + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 2.0, 4.0, 7.0, 11.0, 16.0 ] ); + * var p = new Float64Array( [ 1.0 ] ); + * var a = new Float64Array( [ 22.0 ] ); + * var out = new Float64Array( 5 ); + * var w = new Float64Array( 6 ); + * + * ns.ddiff( x.length, 2, x, 1, 1, p, 1, 1, a, 1, out, 1, w, 1 ); + * + * console.log( out ); + * // out => [ 1.0, 1.0, 1.0, 1.0, 1.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 2.0, 4.0, 7.0, 11.0, 16.0 ] ); + * var p = new Float64Array( [ 1.0 ] ); + * var a = new Float64Array( [ 22.0 ] ); + * var out = new Float64Array( 5 ); + * var w = new Float64Array( 6 ); + * + * ns.ddiff.ndarray( x.length, 2, x, 1, 0, 1, p, 1, 0, 1, a, 1, 0, out, 1, 0, w, 1, 0 ); + * + * console.log( out ); + * // out => [ 1.0, 1.0, 1.0, 1.0, 1.0 ] + */ + ddiff: typeof ddiff; + /** * Fills a double-precision floating-point strided array with a specified scalar value. * @@ -969,6 +1067,32 @@ interface Namespace { */ dnanasumors: typeof dnanasumors; + /** + * Computes the number of non-`NaN` elements in a double-precision floating-point strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns number of non-`NaN` elements + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnancount( x.length, x, 1 ); + * // returns 3 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnancount.ndarray( x.length, x, 1, 0 ); + * // returns 3 + */ + dnancount: typeof dnancount; + /** * Computes the cumulative sum of double-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm. * @@ -2055,6 +2179,66 @@ interface Namespace { */ dsumpw: typeof dsumpw; + /** + * Fills a double-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. + * + * @param N - number of indexed elements + * @param start - starting value + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dunitspace( x.length, 3.0, x, 1 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dunitspace.ndarray( x.length, 3.0, x, 1, 0 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + */ + dunitspace: typeof dunitspace; + + /** + * Generates a double-precision floating-point Vandermonde matrix. + * + * @param order - storage layout + * @param mode - mode indicating whether to generate increasing or decreasing powers + * @param M - number of rows in `out` + * @param N - number of columns in `out` + * @param x - input array + * @param strideX - stride length for `x` + * @param out - output matrix + * @param ldo - stride between successive contiguous vectors of the matrix `out` (a.k.a., leading dimension of the matrix `out`) + * @returns output matrix + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * var out = new Float64Array( 9 ); + * + * ns.dvander( 'row-major', -1, 3, 3, x, 1, out, 3 ); + * // out => [ 1.0, 1.0, 1.0, 4.0, 2.0, 1.0, 9.0, 3.0, 1.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * var out = new Float64Array( 9 ); + * + * ns.dvander.ndarray( -1, 3, 3, x, 1, 0, out, 3, 1, 0 ); + * // out => [ 1.0, 1.0, 1.0, 4.0, 2.0, 1.0, 9.0, 3.0, 1.0 ] + */ + dvander: typeof dvander; + /** * Fills a double-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from zero. * @@ -2783,6 +2967,28 @@ interface Namespace { */ glinspace: typeof glinspace; + /** + * Computes the number of non-`NaN` elements in a strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns count + * + * @example + * var x = [ 1.0, -2.0, NaN, 2.0 ]; + * + * var v = ns.gnancount( x.length, x, 1 ); + * // returns 3 + * + * @example + * var x = [ 1.0, -2.0, NaN, 2.0 ]; + * + * var v = ns.gnancount.ndarray( x.length, x, 1, 0 ); + * // returns 3 + */ + gnancount: typeof gnancount; + /** * Computes the sum of strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm. * @@ -3329,6 +3535,29 @@ interface Namespace { */ gsumpw: typeof gsumpw; + /** + * Fills a strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. + * + * @param N - number of indexed elements + * @param start - starting value + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var x = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gunitspace( x.length, 3.0, x, 1 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var x = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gunitspace.ndarray( x.length, 3.0, x, 1, 0 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + */ + gunitspace: typeof gunitspace; + /** * Generates a Vandermonde matrix. * @@ -3358,6 +3587,40 @@ interface Namespace { */ gvander: typeof gvander; + /** + * Takes elements from one of two strided arrays depending on a condition. + * + * @param N - number of indexed elements + * @param condition - condition array + * @param strideC - stride length for `condition` + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @param out - output array + * @param strideOut - stride length for `out` + * @returns output array + * + * @example + * var condition = [ 1, 0, 1 ]; + * var x = [ 1.0, 2.0, 3.0 ]; + * var y = [ 4.0, 5.0, 6.0 ]; + * var out = [ 0.0, 0.0, 0.0 ]; + * + * ns.gwhere( 3, condition, 1, x, 1, y, 1, out, 1 ); + * // out => [ 1.0, 5.0, 3.0 ] + * + * @example + * var condition = [ 1, 0, 1 ]; + * var x = [ 1.0, 2.0, 3.0 ]; + * var y = [ 4.0, 5.0, 6.0 ]; + * var out = [ 0.0, 0.0, 0.0 ]; + * + * ns.gwhere.ndarray( 3, condition, 1, 0, x, 1, 0, y, 1, 0, out, 1, 0 ); + * // out => [ 1.0, 5.0, 3.0 ] + */ + gwhere: typeof gwhere; + /** * Fills a strided array with linearly spaced numeric elements which increment by `1` starting from zero. * @@ -3755,6 +4018,60 @@ interface Namespace { */ scusumpw: typeof scusumpw; + /** + * Calculates the k-th discrete forward difference of a single-precision floating-point strided array. + * + * ## Notes + * + * - The `out` array must have `N + N1 + N2 - k` elements. + * - The `workspace` array must have `N + N1 + N2 - 1` elements. + * + * @param N - number of indexed elements + * @param k - number of times to recursively compute differences + * @param x - input array + * @param strideX - stride length for `x` + * @param N1 - number of indexed elements for `prepend` + * @param prepend - prepend array + * @param strideP - stride length for `prepend` + * @param N2 - number of indexed elements for `append` + * @param append - append array + * @param strideA - stride length for `append` + * @param out - output array + * @param strideOut - stride length for `out` + * @param workspace - workspace array + * @param strideW - stride length for `workspace` + * @returns output array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, 4.0, 7.0, 11.0, 16.0 ] ); + * var p = new Float32Array( [ 1.0 ] ); + * var a = new Float32Array( [ 22.0 ] ); + * var out = new Float32Array( 5 ); + * var w = new Float32Array( 6 ); + * + * ns.sdiff( x.length, 2, x, 1, 1, p, 1, 1, a, 1, out, 1, w, 1 ); + * + * console.log( out ); + * // out => [ 1.0, 1.0, 1.0, 1.0, 1.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, 4.0, 7.0, 11.0, 16.0 ] ); + * var p = new Float32Array( [ 1.0 ] ); + * var a = new Float32Array( [ 22.0 ] ); + * var out = new Float32Array( 5 ); + * var w = new Float32Array( 6 ); + * + * ns.sdiff.ndarray( x.length, 2, x, 1, 0, 1, p, 1, 0, 1, a, 1, 0, out, 1, 0, w, 1, 0 ); + * + * console.log( out ); + * // out => [ 1.0, 1.0, 1.0, 1.0, 1.0 ] + */ + sdiff: typeof sdiff; + /** * Adds a scalar constant to each single-precision floating-point strided array element and computes the sum using extended accumulation. * @@ -4090,6 +4407,32 @@ interface Namespace { */ slinspace: typeof slinspace; + /** + * Computes the number of non-`NaN` elements in a single-precision floating-point strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns number of non-`NaN` elements + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.snancount( x.length, x, 1 ); + * // returns 3 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.snancount.ndarray( x.length, x, 1, 0 ); + * // returns 3 + */ + snancount: typeof snancount; + /** * Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values. * @@ -4272,6 +4615,33 @@ interface Namespace { */ srev: typeof srev; + /** + * Sorts a single-precision floating-point strided array. + * + * @param N - number of indexed elements + * @param order - sort order + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * + * ns.ssort( x.length, 1.0, x, 1 ); + * // x => [ -4.0, -2.0, 1.0, 3.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 3.0, -4.0 ] ); + * + * ns.ssort.ndarray( x.length, 1.0, x, 1, 0 ); + * // x => [ -4.0, -2.0, 1.0, 3.0 ] + */ + ssort: typeof ssort; + /** * Simultaneously sorts two single-precision floating-point strided arrays based on the sort order of the first array using heapsort. * @@ -4606,6 +4976,66 @@ interface Namespace { */ ssumpw: typeof ssumpw; + /** + * Fills a single-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. + * + * @param N - number of indexed elements + * @param start - starting value + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.sunitspace( x.length, 3.0, x, 1 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.sunitspace.ndarray( x.length, 3.0, x, 1, 0 ); + * // x => [ 3.0, 4.0, 5.0, 6.0 ] + */ + sunitspace: typeof sunitspace; + + /** + * Generates a single-precision floating-point Vandermonde matrix. + * + * @param order - storage layout + * @param mode - mode indicating whether to generate increasing or decreasing powers + * @param M - number of rows in `out` + * @param N - number of columns in `out` + * @param x - input array + * @param strideX - stride length for `x` + * @param out - output matrix + * @param ldo - stride between successive contiguous vectors of the matrix `out` (a.k.a., leading dimension of the matrix `out`) + * @returns output matrix + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * var out = new Float32Array( 9 ); + * + * ns.svander( 'row-major', -1, 3, 3, x, 1, out, 3 ); + * // out => [ 1.0, 1.0, 1.0, 4.0, 2.0, 1.0, 9.0, 3.0, 1.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * var out = new Float32Array( 9 ); + * + * ns.svander.ndarray( -1, 3, 3, x, 1, 0, out, 3, 1, 0 ); + * // out => [ 1.0, 1.0, 1.0, 4.0, 2.0, 1.0, 9.0, 3.0, 1.0 ] + */ + svander: typeof svander; + /** * Fills a single-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from zero. * @@ -4706,6 +5136,32 @@ interface Namespace { */ zindexOfRow: typeof zindexOfRow; + /** + * Computes the number of non-`NaN` elements in a double-precision complex floating-point strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns number of non-`NaN` elements + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, NaN, NaN, 3.0, 4.0 ] ); + * + * var v = ns.znancount( 3, x, 1 ); + * // returns 2 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, NaN, NaN, 3.0, 4.0 ] ); + * + * var v = ns.znancount.ndarray( 3, x, 1, 0 ); + * // returns 2 + */ + znancount: typeof znancount; + /** * Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one. * @@ -4784,6 +5240,35 @@ interface Namespace { */ zsumkbn: typeof zsumkbn; + /** + * Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. + * + * @param N - number of indexed elements + * @param start - starting value + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var x = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zunitspace( x.length, new Complex128( 3.0, 0.0 ), x, 1 ); + * // x => [ 3.0, 0.0, 4.0, 0.0, 5.0, 0.0, 6.0, 0.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var x = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zunitspace.ndarray( x.length, new Complex128( 3.0, 0.0 ), x, 1, 0 ); + * // x => [ 3.0, 0.0, 4.0, 0.0, 5.0, 0.0, 6.0, 0.0 ] + */ + zunitspace: typeof zunitspace; + /** * Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from zero. *