From 496a7d3abf58632e0ff647157701e8f37a2625a2 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Fri, 15 May 2026 03:19:07 +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 | 336 ++++++++++++++++++ 1 file changed, 336 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 844d4df29e48..a1a76b8a0b5b 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 @@ -21,7 +21,10 @@ /* eslint-disable max-lines */ 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 clastIndexOfRow = require( '@stdlib/blas/ext/base/clast-index-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' ); @@ -49,6 +52,7 @@ import dindexOf = require( '@stdlib/blas/ext/base/dindex-of' ); import dindexOfColumn = require( '@stdlib/blas/ext/base/dindex-of-column' ); import dindexOfRow = require( '@stdlib/blas/ext/base/dindex-of-row' ); import dlastIndexOf = require( '@stdlib/blas/ext/base/dlast-index-of' ); +import dlastIndexOfRow = require( '@stdlib/blas/ext/base/dlast-index-of-row' ); import dlinspace = require( '@stdlib/blas/ext/base/dlinspace' ); import dnanasum = require( '@stdlib/blas/ext/base/dnanasum' ); import dnanasumors = require( '@stdlib/blas/ext/base/dnanasumors' ); @@ -176,6 +180,7 @@ import sdssum = require( '@stdlib/blas/ext/base/sdssum' ); import sdssumpw = require( '@stdlib/blas/ext/base/sdssumpw' ); import sfill = require( '@stdlib/blas/ext/base/sfill' ); import sindexOf = require( '@stdlib/blas/ext/base/sindex-of' ); +import sindexOfColumn = require( '@stdlib/blas/ext/base/sindex-of-column' ); import sindexOfRow = require( '@stdlib/blas/ext/base/sindex-of-row' ); import slastIndexOf = require( '@stdlib/blas/ext/base/slast-index-of' ); import slastIndexOfRow = require( '@stdlib/blas/ext/base/slast-index-of-row' ); @@ -206,7 +211,10 @@ import swhere = require( '@stdlib/blas/ext/base/swhere' ); 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 zindexOf = require( '@stdlib/blas/ext/base/zindex-of' ); +import zindexOfColumn = require( '@stdlib/blas/ext/base/zindex-of-column' ); import zindexOfRow = require( '@stdlib/blas/ext/base/zindex-of-row' ); +import zlastIndexOfRow = require( '@stdlib/blas/ext/base/zlast-index-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' ); @@ -252,6 +260,82 @@ interface Namespace { */ cfill: typeof cfill; + /** + * Returns the first index of a specified search element in a single-precision complex floating-point strided array. + * + * ## Notes + * + * - If the function is unable to find a 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 Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * var idx = ns.cindexOf( x.length, new Complex64( 3.0, 4.0 ), x, 1 ); + * // returns 1 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * var idx = ns.cindexOf.ndarray( x.length, new Complex64( 3.0, 4.0 ), x, 1, 0 ); + * // returns 1 + */ + cindexOf: typeof cindexOf; + + /** + * Returns the index of the first column in a single-precision complex floating-point input matrix which has the same elements as a provided search vector. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in row-major order. When the matrix is stored in column-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking column match candidates + * @param strideW - stride length for `workspace` + * @returns column index + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.cindexOfColumn( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 1 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.cindexOfColumn.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 1 + */ + cindexOfColumn: typeof cindexOfColumn; + /** * 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. * @@ -295,6 +379,51 @@ interface Namespace { */ cindexOfRow: typeof cindexOfRow; + /** + * 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. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in column-major order. When the matrix is stored in row-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking row match candidates + * @param strideW - stride length for `workspace` + * @returns row index + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * // A (row-major) => [ [ 1+0i, 2+0i ], [ 3+0i, 4+0i ], [ 3+0i, 4+0i ] ] + * var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] ); + * var x = new Complex64Array( [ 3.0, 0.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.clastIndexOfRow( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 2 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * // A (row-major) => [ [ 1+0i, 2+0i ], [ 3+0i, 4+0i ], [ 3+0i, 4+0i ] ] + * var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] ); + * var x = new Complex64Array( [ 3.0, 0.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.clastIndexOfRow.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 2 + */ + clastIndexOfRow: typeof clastIndexOfRow; + /** * Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one. * @@ -1130,6 +1259,49 @@ interface Namespace { */ dlastIndexOf: typeof dlastIndexOf; + /** + * Returns the index of the last row in a double-precision floating-point input matrix which has the same elements as a provided search vector. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in column-major order. When the matrix is stored in row-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking row match candidates + * @param strideW - stride length for `workspace` + * @returns row index + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 3.0, 4.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 3.0, 4.0 ] ] + * var x = new Float64Array( [ 3.0, 4.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.dlastIndexOfRow( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 2 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 3.0, 4.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 3.0, 4.0 ] ] + * var x = new Float64Array( [ 3.0, 4.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.dlastIndexOfRow.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 2 + */ + dlastIndexOfRow: typeof dlastIndexOfRow; + /** * Fills a double-precision floating-point strided array with linearly spaced values over a specified interval. * @@ -4691,6 +4863,49 @@ interface Namespace { */ sindexOf: typeof sindexOf; + /** + * Returns the index of the first column in a single-precision floating-point input matrix which has the same elements as a provided search vector. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in row-major order. When the matrix is stored in column-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking column match candidates + * @param strideW - stride length for `workspace` + * @returns column index + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 0.0, 0.0 ] ] + * var x = new Float32Array( [ 2.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.sindexOfColumn( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 1 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 0.0, 0.0 ] ] + * var x = new Float32Array( [ 2.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.sindexOfColumn.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 1 + */ + sindexOfColumn: typeof sindexOfColumn; + /** * 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. * @@ -5573,6 +5788,82 @@ interface Namespace { */ zfill: typeof zfill; + /** + * Returns the first index of a specified search element in a double-precision complex floating-point strided array. + * + * ## Notes + * + * - If the function is unable to find a 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 Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * var idx = ns.zindexOf( x.length, new Complex128( 3.0, 4.0 ), x, 1 ); + * // returns 1 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * var idx = ns.zindexOf.ndarray( x.length, new Complex128( 3.0, 4.0 ), x, 1, 0 ); + * // returns 1 + */ + zindexOf: typeof zindexOf; + + /** + * Returns the index of the first column in a double-precision complex floating-point input matrix which has the same elements as a provided search vector. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in row-major order. When the matrix is stored in column-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking column match candidates + * @param strideW - stride length for `workspace` + * @returns column index + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Complex128Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var x = new Complex128Array( [ 2.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.zindexOfColumn( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 1 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var A = new Complex128Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var x = new Complex128Array( [ 2.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); + * var workspace = new Uint8Array( 2 ); + * + * var out = ns.zindexOfColumn.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 1 + */ + zindexOfColumn: typeof zindexOfColumn; + /** * 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. * @@ -5616,6 +5907,51 @@ interface Namespace { */ zindexOfRow: typeof zindexOfRow; + /** + * 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. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index). + * - The `workspace` array is only applicable when an input matrix is stored in column-major order. When the matrix is stored in row-major order, the workspace array is ignored. + * + * @param order - storage layout + * @param M - number of rows in `A` + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - search vector + * @param strideX - stride length for `x` + * @param workspace - workspace array for tracking row match candidates + * @param strideW - stride length for `workspace` + * @returns row index + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * // A (row-major) => [ [ 1+0i, 2+0i ], [ 3+0i, 4+0i ], [ 3+0i, 4+0i ] ] + * var A = new Complex128Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] ); + * var x = new Complex128Array( [ 3.0, 0.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.zlastIndexOfRow( 'row-major', 3, 2, A, 2, x, 1, workspace, 1 ); + * // returns 2 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * // A (row-major) => [ [ 1+0i, 2+0i ], [ 3+0i, 4+0i ], [ 3+0i, 4+0i ] ] + * var A = new Complex128Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] ); + * var x = new Complex128Array( [ 3.0, 0.0, 4.0, 0.0 ] ); + * var workspace = new Uint8Array( 3 ); + * + * var out = ns.zlastIndexOfRow.ndarray( 3, 2, A, 2, 1, 0, x, 1, 0, workspace, 1, 0 ); + * // returns 2 + */ + zlastIndexOfRow: typeof zlastIndexOfRow; + /** * Computes the number of non-`NaN` elements in a double-precision complex floating-point strided array. *