From c1dd5ab9cad7a37c9c664ff2f79d0240ce1e7ec0 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Sat, 1 Aug 2026 03:11:42 +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 | 268 ++++++++++++++++++ 1 file changed, 268 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 3111a15e228f..af4e8a818574 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 @@ -27,6 +27,7 @@ import cdiff = require( '@stdlib/blas/ext/base/cdiff' ); 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 cindexOfFalsy = require( '@stdlib/blas/ext/base/cindex-of-falsy' ); 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' ); @@ -75,6 +76,7 @@ import dfillEqual = require( '@stdlib/blas/ext/base/dfill-equal' ); import dfillNaN = require( '@stdlib/blas/ext/base/dfill-nan' ); import dfillNotEqual = require( '@stdlib/blas/ext/base/dfill-not-equal' ); import dfirstIndexEqual = require( '@stdlib/blas/ext/base/dfirst-index-equal' ); +import dfirstIndexGreaterThan = require( '@stdlib/blas/ext/base/dfirst-index-greater-than' ); import dfirstIndexLessThan = require( '@stdlib/blas/ext/base/dfirst-index-less-than' ); import dindexOf = require( '@stdlib/blas/ext/base/dindex-of' ); import dindexOfColumn = require( '@stdlib/blas/ext/base/dindex-of-column' ); @@ -136,6 +138,7 @@ 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 dtriu = require( '@stdlib/blas/ext/base/dtriu' ); import dunitspace = require( '@stdlib/blas/ext/base/dunitspace' ); import dvander = require( '@stdlib/blas/ext/base/dvander' ); import dwapx = require( '@stdlib/blas/ext/base/dwapx' ); @@ -295,6 +298,7 @@ import sfirstIndexLessThan = require( '@stdlib/blas/ext/base/sfirst-index-less-t import sindexOf = require( '@stdlib/blas/ext/base/sindex-of' ); import sindexOfColumn = require( '@stdlib/blas/ext/base/sindex-of-column' ); import sindexOfFalsy = require( '@stdlib/blas/ext/base/sindex-of-falsy' ); +import sindexOfNotEqual = require( '@stdlib/blas/ext/base/sindex-of-not-equal' ); import sindexOfRow = require( '@stdlib/blas/ext/base/sindex-of-row' ); import sindexOfTruthy = require( '@stdlib/blas/ext/base/sindex-of-truthy' ); import slastIndexOf = require( '@stdlib/blas/ext/base/slast-index-of' ); @@ -329,6 +333,7 @@ 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 striu = require( '@stdlib/blas/ext/base/striu' ); import sunitspace = require( '@stdlib/blas/ext/base/sunitspace' ); import svander = require( '@stdlib/blas/ext/base/svander' ); import swapx = require( '@stdlib/blas/ext/base/swapx' ); @@ -346,6 +351,7 @@ import sxsy = require( '@stdlib/blas/ext/base/sxsy' ); import szeroTo = require( '@stdlib/blas/ext/base/szero-to' ); import szeros = require( '@stdlib/blas/ext/base/szeros' ); import wasm = require( '@stdlib/blas/ext/base/wasm' ); +import zany = require( '@stdlib/blas/ext/base/zany' ); import zapx = require( '@stdlib/blas/ext/base/zapx' ); import zaxpb = require( '@stdlib/blas/ext/base/zaxpb' ); import zaxpby = require( '@stdlib/blas/ext/base/zaxpby' ); @@ -358,6 +364,7 @@ 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 zlastIndexOfFalsy = require( '@stdlib/blas/ext/base/zlast-index-of-falsy' ); import zlastIndexOfRow = require( '@stdlib/blas/ext/base/zlast-index-of-row' ); import zlogspace = require( '@stdlib/blas/ext/base/zlogspace' ); import znancount = require( '@stdlib/blas/ext/base/znancount' ); @@ -369,6 +376,7 @@ import zunitspace = require( '@stdlib/blas/ext/base/zunitspace' ); import zwapx = require( '@stdlib/blas/ext/base/zwapx' ); import zwax = require( '@stdlib/blas/ext/base/zwax' ); import zwhere = require( '@stdlib/blas/ext/base/zwhere' ); +import zwxmy = require( '@stdlib/blas/ext/base/zwxmy' ); import zwxsa = require( '@stdlib/blas/ext/base/zwxsa' ); import zxdy = require( '@stdlib/blas/ext/base/zxdy' ); import zxmy = require( '@stdlib/blas/ext/base/zxmy' ); @@ -649,6 +657,38 @@ interface Namespace { */ cindexOfColumn: typeof cindexOfColumn; + /** + * Returns the index of the first falsy element in a single-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 Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 0.0, 0.0 ] ); + * + * var idx = ns.cindexOfFalsy( x.length, x, 1 ); + * // returns 1 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 0.0, 0.0 ] ); + * + * var idx = ns.cindexOfFalsy.ndarray( x.length, x, 1, 0 ); + * // returns 1 + */ + cindexOfFalsy: typeof cindexOfFalsy; + /** * Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector. * @@ -2195,6 +2235,40 @@ interface Namespace { */ dfirstIndexEqual: typeof dfirstIndexEqual; + /** + * Returns the index of the first element in a double-precision floating-point strided array which is greater than a corresponding element in another double-precision floating-point strided array. + * + * ## Notes + * + * - If the function is unable to find an element in `x` which is greater than a corresponding element in `y`, the function returns `-1`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float64Array( [ 2.0, 2.0, 2.0, 2.0 ] ); + * + * var idx = ns.dfirstIndexGreaterThan( 4, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float64Array( [ 2.0, 2.0, 2.0, 2.0 ] ); + * + * var idx = ns.dfirstIndexGreaterThan.ndarray( 4, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + dfirstIndexGreaterThan: typeof dfirstIndexGreaterThan; + /** * Returns the index of the first element in a double-precision floating-point strided array which is less than a corresponding element in another double-precision floating-point strided array. * @@ -4039,6 +4113,39 @@ interface Namespace { */ dsumpw: typeof dsumpw; + /** + * Copies the upper triangular part of a double-precision floating-point matrix `A` to another matrix `B`. + * + * @param order - storage layout of `A` and `B` + * @param M - number of rows in matrix `A` + * @param N - number of columns in matrix `A` + * @param k - diagonal below which to ignore + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param B - output matrix + * @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`) + * @returns `B` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dtriu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dtriu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + */ + dtriu: typeof dtriu; + /** * Fills a double-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -8546,6 +8653,37 @@ interface Namespace { */ sindexOfFalsy: typeof sindexOfFalsy; + /** + * Returns the first index of an element in a single-precision floating-point strided array which is not equal to a specified search element. + * + * ## Notes + * + * - If all elements are equal to the search element, the function returns `-1`. + * + * @param N - number of indexed elements + * @param searchElement - search element + * @param x - input array + * @param strideX - stride length + * @returns index + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 1.0, 0.0, 1.0 ] ); + * + * var idx = ns.sindexOfNotEqual( x.length, 1.0, x, 1 ); + * // returns 2 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 1.0, 0.0, 1.0 ] ); + * + * var idx = ns.sindexOfNotEqual.ndarray( x.length, 1.0, x, 1, 0 ); + * // returns 2 + */ + sindexOfNotEqual: typeof sindexOfNotEqual; + /** * Returns the index of the first row in a single-precision floating-point input matrix which has the same elements as a provided search vector. * @@ -9595,6 +9733,39 @@ interface Namespace { */ ssumpw: typeof ssumpw; + /** + * Copies the upper triangular part of a single-precision floating-point matrix `A` to another matrix `B`. + * + * @param order - storage layout of `A` and `B` + * @param M - number of rows in matrix `A` + * @param N - number of columns in matrix `A` + * @param k - diagonal below which to ignore + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param B - output matrix + * @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`) + * @returns `B` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.striu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.striu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + */ + striu: typeof striu; + /** * Fills a single-precision floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -10094,6 +10265,37 @@ interface Namespace { */ wasm: typeof wasm; + /** + * Tests whether at least one element in a double-precision complex floating-point strided array is truthy. + * + * ## Notes + * + * - A complex number is truthy when at least one of its real or imaginary components is truthy. + * - The function explicitly treats `NaN` values as falsy. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns boolean indicating whether at least one element is truthy + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 0.0, 0.0, 1.0, 2.0 ] ); + * + * var v = ns.zany( x.length, x, 1 ); + * // returns true + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 0.0, 0.0, 1.0, 2.0 ] ); + * + * var v = ns.zany.ndarray( x.length, x, 1, 0 ); + * // returns true + */ + zany: typeof zany; + /** * Adds a scalar constant to each element in a double-precision complex floating-point strided array. * @@ -10529,6 +10731,38 @@ interface Namespace { */ zindexOfTruthy: typeof zindexOfTruthy; + /** + * Returns the index of the last 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, 3.0, 4.0, 0.0, 0.0 ] ); + * + * var idx = ns.zlastIndexOfFalsy( x.length, x, 1 ); + * // returns 2 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0 ] ); + * + * var idx = ns.zlastIndexOfFalsy.ndarray( x.length, x, 1, 0 ); + * // returns 2 + */ + zlastIndexOfFalsy: typeof zlastIndexOfFalsy; + /** * Returns the index of the last row in a double-precision complex floating-point input matrix which has the same elements as a provided search vector. * @@ -10914,6 +11148,40 @@ interface Namespace { */ zwhere: typeof zwhere; + /** + * Multiplies elements of a double-precision complex floating-point strided array `x` by the corresponding elements of a double-precision complex floating-point strided array `y` and assigns the results to elements in a double-precision complex 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 output array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ] ); + * var w = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zwxmy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ -4.0, 7.0, -8.0, 31.0, -12.0, 71.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ] ); + * var w = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zwxmy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ -4.0, 7.0, -8.0, 31.0, -12.0, 71.0 ] + */ + zwxmy: typeof zwxmy; + /** * Subtracts a scalar constant from each element in a double-precision complex floating-point strided array `x` and assigns the results to elements in a double-precision complex floating-point strided array `w`. *