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 72c6c08a8709..43ef38234769 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 @@ -22,6 +22,8 @@ import caxpb = require( '@stdlib/blas/ext/base/ndarray/caxpb' ); import caxpby = require( '@stdlib/blas/ext/base/ndarray/caxpby' ); +import ccopyWithin = require( '@stdlib/blas/ext/base/ndarray/ccopy-within' ); +import cfillEqual = require( '@stdlib/blas/ext/base/ndarray/cfill-equal' ); import cindexOf = require( '@stdlib/blas/ext/base/ndarray/cindex-of' ); import cindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/cindex-of-truthy' ); import coneTo = require( '@stdlib/blas/ext/base/ndarray/cone-to' ); @@ -49,6 +51,7 @@ import ddiff = require( '@stdlib/blas/ext/base/ndarray/ddiff' ); import dfillEqual = require( '@stdlib/blas/ext/base/ndarray/dfill-equal' ); import dfillNaN = require( '@stdlib/blas/ext/base/ndarray/dfill-nan' ); import dfillNotEqual = require( '@stdlib/blas/ext/base/ndarray/dfill-not-equal' ); +import dfirstIndexEqual = require( '@stdlib/blas/ext/base/ndarray/dfirst-index-equal' ); import dfirstIndexGreaterThan = require( '@stdlib/blas/ext/base/ndarray/dfirst-index-greater-than' ); import dfirstIndexLessThan = require( '@stdlib/blas/ext/base/ndarray/dfirst-index-less-than' ); import dindexOf = require( '@stdlib/blas/ext/base/ndarray/dindex-of' ); @@ -57,6 +60,7 @@ import dindexOfNotEqual = require( '@stdlib/blas/ext/base/ndarray/dindex-of-not- import dindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/dindex-of-truthy' ); import dlastIndexEqual = require( '@stdlib/blas/ext/base/ndarray/dlast-index-equal' ); import dlastIndexOf = require( '@stdlib/blas/ext/base/ndarray/dlast-index-of' ); +import dlastIndexOfFalsy = require( '@stdlib/blas/ext/base/ndarray/dlast-index-of-falsy' ); 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' ); @@ -97,6 +101,7 @@ import gfillNaN = require( '@stdlib/blas/ext/base/ndarray/gfill-nan' ); import gfillNotEqual = require( '@stdlib/blas/ext/base/ndarray/gfill-not-equal' ); import gfindIndex = require( '@stdlib/blas/ext/base/ndarray/gfind-index' ); import gfindLastIndex = require( '@stdlib/blas/ext/base/ndarray/gfind-last-index' ); +import gfirstIndexEqual = require( '@stdlib/blas/ext/base/ndarray/gfirst-index-equal' ); import gfirstIndexGreaterThan = require( '@stdlib/blas/ext/base/ndarray/gfirst-index-greater-than' ); import gfirstIndexLessThan = require( '@stdlib/blas/ext/base/ndarray/gfirst-index-less-than' ); import gindexOf = require( '@stdlib/blas/ext/base/ndarray/gindex-of' ); @@ -107,6 +112,7 @@ import gjoin = require( '@stdlib/blas/ext/base/ndarray/gjoin' ); import gjoinBetween = require( '@stdlib/blas/ext/base/ndarray/gjoin-between' ); import glastIndexEqual = require( '@stdlib/blas/ext/base/ndarray/glast-index-equal' ); import glastIndexOf = require( '@stdlib/blas/ext/base/ndarray/glast-index-of' ); +import glastIndexOfFalsy = require( '@stdlib/blas/ext/base/ndarray/glast-index-of-falsy' ); 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' ); @@ -140,8 +146,10 @@ 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 sfillEqual = require( '@stdlib/blas/ext/base/ndarray/sfill-equal' ); import sfillNaN = require( '@stdlib/blas/ext/base/ndarray/sfill-nan' ); import sfillNotEqual = require( '@stdlib/blas/ext/base/ndarray/sfill-not-equal' ); +import sfirstIndexEqual = require( '@stdlib/blas/ext/base/ndarray/sfirst-index-equal' ); import sfirstIndexLessThan = require( '@stdlib/blas/ext/base/ndarray/sfirst-index-less-than' ); import sindexOf = require( '@stdlib/blas/ext/base/ndarray/sindex-of' ); import sindexOfNotEqual = require( '@stdlib/blas/ext/base/ndarray/sindex-of-not-equal' ); @@ -172,6 +180,7 @@ import sxsy = require( '@stdlib/blas/ext/base/ndarray/sxsy' ); import szeroTo = require( '@stdlib/blas/ext/base/ndarray/szero-to' ); import zaxpb = require( '@stdlib/blas/ext/base/ndarray/zaxpb' ); import zaxpby = require( '@stdlib/blas/ext/base/ndarray/zaxpby' ); +import zcopyWithin = require( '@stdlib/blas/ext/base/ndarray/zcopy-within' ); import zindexOf = require( '@stdlib/blas/ext/base/ndarray/zindex-of' ); import zindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/zindex-of-truthy' ); import zoneTo = require( '@stdlib/blas/ext/base/ndarray/zone-to' ); @@ -261,6 +270,83 @@ interface Namespace { */ caxpby: typeof caxpby; + /** + * Performs an in-place copy of elements within a one-dimensional single-precision complex floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying a target index. + * - a zero-dimensional ndarray specifying a source start index (inclusive). + * - a zero-dimensional ndarray specifying a source end index (exclusive). + * - a one-dimensional workspace ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var zeros = require( '@stdlib/ndarray/zeros' ); + * + * var x = new Complex64Vector( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var target = scalar2ndarray( 1, { + * 'dtype': 'generic' + * }); + * var start = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * var end = scalar2ndarray( 2, { + * 'dtype': 'generic' + * }); + * + * var w = zeros( [ 3 ], { + * 'dtype': 'complex64' + * }); + * + * var out = ns.ccopyWithin( [ x, target, start, end, w ] ); + * // returns [ [ 1.0, 2.0 ], [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] + */ + ccopyWithin: typeof ccopyWithin; + + /** + * Replaces elements in a one-dimensional single-precision complex floating-point ndarray equal to a provided search element with a specified scalar constant. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray containing the search element. + * - a zero-dimensional ndarray containing the scalar constant. + * + * - When comparing elements, the function checks for equality of real and imaginary components using the strict equality operator `===`. As a consequence, `NaN` components are considered distinct (i.e., as `NaN === NaN` always evaluates to `false`, elements having one or more `NaN` components are never replaced), and `-0` and `+0` are considered the same. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var x = new Complex64Vector( [ 0.0, 0.0, -2.0, 3.0, 0.0, 0.0, 4.0, -6.0 ] ); + * + * var searchElement = scalar2ndarray( new Complex64( 0.0, 0.0 ), { + * 'dtype': 'complex64' + * }); + * + * var alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), { + * 'dtype': 'complex64' + * }); + * + * var out = ns.cfillEqual( [ x, searchElement, alpha ] ); + * // returns [ [ 5.0, 5.0 ], [ -2.0, 3.0 ], [ 5.0, 5.0 ], [ 4.0, -6.0 ] ] + */ + cfillEqual: typeof cfillEqual; + /** * Returns the first index of a search element in a one-dimensional single-precision complex floating-point ndarray. * @@ -1058,6 +1144,32 @@ interface Namespace { */ dfillNotEqual: typeof dfillNotEqual; + /** + * Returns the index of the first element in a one-dimensional double-precision floating-point ndarray equal to a corresponding element in another one-dimensional double-precision floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - first one-dimensional input ndarray. + * - second one-dimensional input ndarray. + * + * - When comparing elements, the function checks for equality using the strict equality operator `===`. As a consequence, `NaN` values are considered distinct, and `-0` and `+0` are considered the same. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); + * + * var x = new Float64Vector( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float64Vector( [ 0.0, 0.0, 3.0, 0.0 ] ); + * + * var idx = ns.dfirstIndexEqual( [ x, y ] ); + * // returns 2 + */ + dfirstIndexEqual: typeof dfirstIndexEqual; + /** * Returns the index of the first element in a one-dimensional double-precision floating-point ndarray which is greater than a corresponding element in another one-dimensional double-precision floating-point ndarray. * @@ -1274,6 +1386,28 @@ interface Namespace { */ dlastIndexOf: typeof dlastIndexOf; + /** + * Returns the index of the last falsy element in a one-dimensional double-precision floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); + * + * var x = new Float64Vector( [ 1.0, 0.0, 3.0, 0.0 ] ); + * + * var v = ns.dlastIndexOfFalsy( [ x ] ); + * // returns 3 + */ + dlastIndexOfFalsy: typeof dlastIndexOfFalsy; + /** * Fills a one-dimensional double-precision floating-point ndarray with linearly spaced values over a specified interval. * @@ -2388,6 +2522,32 @@ interface Namespace { */ gfindLastIndex: typeof gfindLastIndex; + /** + * Returns the index of the first element in a one-dimensional ndarray equal to a corresponding element in another one-dimensional ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - first one-dimensional input ndarray. + * - second one-dimensional input ndarray. + * + * - When comparing elements, the function checks for equality using the strict equality operator `===`. As a consequence, `NaN` values are considered distinct, and `-0` and `+0` are considered the same. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var vector = require( '@stdlib/ndarray/vector/ctor' ); + * + * var x = vector( [ 1.0, 2.0, 3.0, 4.0 ], 'generic' ); + * var y = vector( [ 0.0, 0.0, 3.0, 0.0 ], 'generic' ); + * + * var idx = ns.gfirstIndexEqual( [ x, y ] ); + * // returns 2 + */ + gfirstIndexEqual: typeof gfirstIndexEqual; + /** * Returns the index of the first element in a one-dimensional ndarray which is greater than a corresponding element in another one-dimensional ndarray. * @@ -2662,6 +2822,28 @@ interface Namespace { */ glastIndexOf: typeof glastIndexOf; + /** + * Returns the index of the last falsy element in a one-dimensional ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var vector = require( '@stdlib/ndarray/vector/ctor' ); + * + * var x = vector( [ 0.0, 3.0, 0.0, 2.0 ], 'generic' ); + * + * var v = ns.glastIndexOfFalsy( [ x ] ); + * // returns 2 + */ + glastIndexOfFalsy: typeof glastIndexOfFalsy; + /** * Fills a one-dimensional ndarray with linearly spaced values over a specified interval. * @@ -3563,6 +3745,41 @@ interface Namespace { */ scusumors: typeof scusumors; + /** + * Replaces elements in a one-dimensional single-precision floating-point ndarray equal to a provided search element with a specified scalar constant. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray containing the search element. + * - a zero-dimensional ndarray containing the scalar constant. + * + * - When comparing elements, the function checks for equality using the strict equality operator `===`. As a consequence, `NaN` values are considered distinct and `-0` and `+0` are considered the same. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var x = new Float32Vector( [ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ] ); + * + * var searchElement = scalar2ndarray( 0.0, { + * 'dtype': 'float32' + * }); + * + * var alpha = scalar2ndarray( 5.0, { + * 'dtype': 'float32' + * }); + * + * var out = ns.sfillEqual( [ x, searchElement, alpha ] ); + * // returns [ 5.0, -2.0, 3.0, 5.0, 4.0, -6.0 ] + */ + sfillEqual: typeof sfillEqual; + /** * Replaces elements in a one-dimensional single-precision floating-point ndarray equal to `NaN` with a specified scalar constant. * @@ -3626,6 +3843,32 @@ interface Namespace { */ sfillNotEqual: typeof sfillNotEqual; + /** + * Returns the index of the first element in a one-dimensional single-precision floating-point ndarray equal to a corresponding element in another one-dimensional single-precision floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - first one-dimensional input ndarray. + * - second one-dimensional input ndarray. + * + * - When comparing elements, the function checks for equality using the strict equality operator `===`. As a consequence, `NaN` values are considered distinct, and `-0` and `+0` are considered the same. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * + * var x = new Float32Vector( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float32Vector( [ 0.0, 0.0, 3.0, 0.0 ] ); + * + * var idx = ns.sfirstIndexEqual( [ x, y ] ); + * // returns 2 + */ + sfirstIndexEqual: typeof sfirstIndexEqual; + /** * Returns the index of the first element in a one-dimensional single-precision floating-point ndarray which is less than a corresponding element in another one-dimensional single-precision floating-point ndarray. * @@ -4421,6 +4664,47 @@ interface Namespace { */ zaxpby: typeof zaxpby; + /** + * Performs an in-place copy of elements within a one-dimensional double-precision complex floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying a target index. + * - a zero-dimensional ndarray specifying a source start index (inclusive). + * - a zero-dimensional ndarray specifying a source end index (exclusive). + * - a one-dimensional workspace ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var zeros = require( '@stdlib/ndarray/zeros' ); + * + * var x = new Complex128Vector( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var target = scalar2ndarray( 1, { + * 'dtype': 'generic' + * }); + * var start = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * var end = scalar2ndarray( 2, { + * 'dtype': 'generic' + * }); + * + * var w = zeros( [ 3 ], { + * 'dtype': 'complex128' + * }); + * + * var out = ns.zcopyWithin( [ x, target, start, end, w ] ); + * // returns [ [ 1.0, 2.0 ], [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] + */ + zcopyWithin: typeof zcopyWithin; + /** * Returns the first index of a search element in a one-dimensional double-precision complex floating-point ndarray. *