From 4138c0a798b2931b1544477efcf3b08a76e10099 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Fri, 31 Jul 2026 03:13:11 +0000 Subject: [PATCH] feat: update `blas/ext/base` TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../blas/ext/base/docs/types/index.d.ts | 206 ++++++++++++++++++ 1 file changed, 206 insertions(+) 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 3f5139cd2d6a..3111a15e228f 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 @@ -28,6 +28,7 @@ import cfill = require( '@stdlib/blas/ext/base/cfill' ); import cindexOf = require( '@stdlib/blas/ext/base/cindex-of' ); import cindexOfColumn = require( '@stdlib/blas/ext/base/cindex-of-column' ); import cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' ); +import cindexOfTruthy = require( '@stdlib/blas/ext/base/cindex-of-truthy' ); import clastIndexOfRow = require( '@stdlib/blas/ext/base/clast-index-of-row' ); import clogspace = require( '@stdlib/blas/ext/base/clogspace' ); import coneTo = require( '@stdlib/blas/ext/base/cone-to' ); @@ -143,6 +144,7 @@ import dwhere = require( '@stdlib/blas/ext/base/dwhere' ); import dwxmy = require( '@stdlib/blas/ext/base/dwxmy' ); import dwxpy = require( '@stdlib/blas/ext/base/dwxpy' ); import dwxsa = require( '@stdlib/blas/ext/base/dwxsa' ); +import dwxsy = require( '@stdlib/blas/ext/base/dwxsy' ); import dxdy = require( '@stdlib/blas/ext/base/dxdy' ); import dxmy = require( '@stdlib/blas/ext/base/dxmy' ); import dxpy = require( '@stdlib/blas/ext/base/dxpy' ); @@ -332,7 +334,10 @@ import svander = require( '@stdlib/blas/ext/base/svander' ); import swapx = require( '@stdlib/blas/ext/base/swapx' ); import swax = require( '@stdlib/blas/ext/base/swax' ); import swhere = require( '@stdlib/blas/ext/base/swhere' ); +import swxmy = require( '@stdlib/blas/ext/base/swxmy' ); +import swxpy = require( '@stdlib/blas/ext/base/swxpy' ); import swxsa = require( '@stdlib/blas/ext/base/swxsa' ); +import swxsy = require( '@stdlib/blas/ext/base/swxsy' ); import sxdy = require( '@stdlib/blas/ext/base/sxdy' ); import sxmy = require( '@stdlib/blas/ext/base/sxmy' ); import sxpy = require( '@stdlib/blas/ext/base/sxpy' ); @@ -350,6 +355,7 @@ import zdiff = require( '@stdlib/blas/ext/base/zdiff' ); import zfill = require( '@stdlib/blas/ext/base/zfill' ); import zindexOf = require( '@stdlib/blas/ext/base/zindex-of' ); import zindexOfColumn = require( '@stdlib/blas/ext/base/zindex-of-column' ); +import zindexOfFalsy = require( '@stdlib/blas/ext/base/zindex-of-falsy' ); import zindexOfRow = require( '@stdlib/blas/ext/base/zindex-of-row' ); import zindexOfTruthy = require( '@stdlib/blas/ext/base/zindex-of-truthy' ); import zlastIndexOfRow = require( '@stdlib/blas/ext/base/zlast-index-of-row' ); @@ -686,6 +692,38 @@ interface Namespace { */ cindexOfRow: typeof cindexOfRow; + /** + * Returns the index of the first truthy element in a single-precision complex floating-point strided array. + * + * ## Notes + * + * - A complex number is truthy when at least one of its real or imaginary components is truthy. + * - If unable to find a truthy element, the function returns `-1`. + * - The function explicitly treats `NaN` values as falsy. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns index + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 0.0, 0.0, 1.0, 0.0, 2.0, 0.0 ] ); + * + * var idx = ns.cindexOfTruthy( x.length, x, 1 ); + * // returns 1 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 0.0, 0.0, 1.0, 0.0, 2.0, 0.0 ] ); + * + * var idx = ns.cindexOfTruthy.ndarray( x.length, x, 1, 0 ); + * // returns 1 + */ + cindexOfTruthy: typeof cindexOfTruthy; + /** * Returns the index of the last row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector. * @@ -4260,6 +4298,40 @@ interface Namespace { */ dwxsa: typeof dwxsa; + /** + * Subtracts elements of a double-precision floating-point strided array `y` from the corresponding elements of a double-precision floating-point strided array `x` and assigns the results to elements in a double-precision floating-point strided array `w`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param w - output array + * @param strideW - `w` stride length + * @returns `w` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 2.0, -4.0, 6.0, 5.0, -7.0 ] ); + * var y = new Float64Array( [ 5.0, 3.0, 2.0, -7.0, 1.0 ] ); + * var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dwxsy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ -3.0, -7.0, 4.0, 12.0, -8.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 2.0, -4.0, 6.0, 5.0, -7.0 ] ); + * var y = new Float64Array( [ 5.0, 3.0, 2.0, -7.0, 1.0 ] ); + * var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dwxsy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ -3.0, -7.0, 4.0, 12.0, -8.0 ] + */ + dwxsy: typeof dwxsy; + /** * Divides elements of a double-precision floating-point strided array `x` by the corresponding elements of a double-precision floating-point strided array `y` and assigns the results to `y`. * @@ -9685,6 +9757,74 @@ interface Namespace { */ swhere: typeof swhere; + /** + * Multiplies elements of a single-precision floating-point strided array `x` by the corresponding elements of a single-precision floating-point strided array `y` and assigns the results to elements in a single-precision floating-point strided array `w`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param w - output array + * @param strideW - `w` stride length + * @returns `w` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxmy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ 2.0, 6.0, 12.0, 20.0, 30.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxmy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ 2.0, 6.0, 12.0, 20.0, 30.0 ] + */ + swxmy: typeof swxmy; + + /** + * Adds elements of a single-precision floating-point strided array `x` to the corresponding elements of a single-precision floating-point strided array `y` and assigns the results to elements in a single-precision floating-point strided array `w`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param w - output array + * @param strideW - `w` stride length + * @returns `w` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxpy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ 3.0, 5.0, 7.0, 9.0, 11.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxpy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ 3.0, 5.0, 7.0, 9.0, 11.0 ] + */ + swxpy: typeof swxpy; + /** * Subtracts a scalar constant from each element in a single-precision floating-point strided array `x` and assigns the results to a single-precision floating-point strided array `w`. * @@ -9716,6 +9856,40 @@ interface Namespace { */ swxsa: typeof swxsa; + /** + * Subtracts elements of a single-precision floating-point strided array `y` from the corresponding elements of a single-precision floating-point strided array `x` and assigns the results to elements in a single-precision floating-point strided array `w`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param w - output array + * @param strideW - `w` stride length + * @returns `w` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, -4.0, 6.0, 5.0, -7.0 ] ); + * var y = new Float32Array( [ 5.0, 3.0, 2.0, -7.0, 1.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxsy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ -3.0, -7.0, 4.0, 12.0, -8.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, -4.0, 6.0, 5.0, -7.0 ] ); + * var y = new Float32Array( [ 5.0, 3.0, 2.0, -7.0, 1.0 ] ); + * var w = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.swxsy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ -3.0, -7.0, 4.0, 12.0, -8.0 ] + */ + swxsy: typeof swxsy; + /** * Divides elements of a single-precision floating-point strided array `x` by the corresponding elements of a single-precision floating-point strided array `y` and assigns the results to `y`. * @@ -10248,6 +10422,38 @@ interface Namespace { */ zindexOfColumn: typeof zindexOfColumn; + /** + * Returns the index of the first falsy element in a double-precision complex floating-point strided array. + * + * ## Notes + * + * - A complex number is falsy when both its real and imaginary components are falsy. + * - If unable to find a falsy element, the function returns `-1`. + * - The function explicitly treats `NaN` values as falsy. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns index + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 0.0, 0.0 ] ); + * + * var idx = ns.zindexOfFalsy( x.length, x, 1 ); + * // returns 1 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 0.0, 0.0 ] ); + * + * var idx = ns.zindexOfFalsy.ndarray( x.length, x, 1, 0 ); + * // returns 1 + */ + zindexOfFalsy: typeof zindexOfFalsy; + /** * Returns the index of the first row in a double-precision complex floating-point input matrix which has the same elements as a provided search vector. *