From 96ebac30f5cc9a1bcc983a68d6740b2773140e79 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Wed, 5 Aug 2026 03:11:17 +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 | 205 ++++++++++++++++++ 1 file changed, 205 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 b7ce476ae156..ccf15b9f14c0 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 @@ -36,6 +36,7 @@ import coneTo = require( '@stdlib/blas/ext/base/cone-to' ); import creplicate = require( '@stdlib/blas/ext/base/creplicate' ); import csum = require( '@stdlib/blas/ext/base/csum' ); import csumkbn = require( '@stdlib/blas/ext/base/csumkbn' ); +import ctriu = require( '@stdlib/blas/ext/base/ctriu' ); import cunitspace = require( '@stdlib/blas/ext/base/cunitspace' ); import cwapx = require( '@stdlib/blas/ext/base/cwapx' ); import cwax = require( '@stdlib/blas/ext/base/cwax' ); @@ -149,6 +150,7 @@ import dvander = require( '@stdlib/blas/ext/base/dvander' ); import dwapx = require( '@stdlib/blas/ext/base/dwapx' ); import dwax = require( '@stdlib/blas/ext/base/dwax' ); import dwhere = require( '@stdlib/blas/ext/base/dwhere' ); +import dwxdy = require( '@stdlib/blas/ext/base/dwxdy' ); import dwxmy = require( '@stdlib/blas/ext/base/dwxmy' ); import dwxpy = require( '@stdlib/blas/ext/base/dwxpy' ); import dwxsa = require( '@stdlib/blas/ext/base/dwxsa' ); @@ -203,6 +205,7 @@ import gfirstIndexNotEqual = require( '@stdlib/blas/ext/base/gfirst-index-not-eq import gindexOf = require( '@stdlib/blas/ext/base/gindex-of' ); import gindexOfColumn = require( '@stdlib/blas/ext/base/gindex-of-column' ); import gindexOfFalsy = require( '@stdlib/blas/ext/base/gindex-of-falsy' ); +import gindexOfFalsyRow = require( '@stdlib/blas/ext/base/gindex-of-falsy-row' ); import gindexOfNotEqual = require( '@stdlib/blas/ext/base/gindex-of-not-equal' ); import gindexOfRow = require( '@stdlib/blas/ext/base/gindex-of-row' ); import gindexOfSameValue = require( '@stdlib/blas/ext/base/gindex-of-same-value' ); @@ -280,6 +283,7 @@ import scartesianPower = require( '@stdlib/blas/ext/base/scartesian-power' ); import scartesianProduct = require( '@stdlib/blas/ext/base/scartesian-product' ); import scartesianSquare = require( '@stdlib/blas/ext/base/scartesian-square' ); import scircshift = require( '@stdlib/blas/ext/base/scircshift' ); +import scopyWithin = require( '@stdlib/blas/ext/base/scopy-within' ); import scuany = require( '@stdlib/blas/ext/base/scuany' ); import scuevery = require( '@stdlib/blas/ext/base/scuevery' ); import scunone = require( '@stdlib/blas/ext/base/scunone' ); @@ -348,6 +352,7 @@ 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 swxdy = require( '@stdlib/blas/ext/base/swxdy' ); import swxmy = require( '@stdlib/blas/ext/base/swxmy' ); import swxpy = require( '@stdlib/blas/ext/base/swxpy' ); import swxsa = require( '@stdlib/blas/ext/base/swxsa' ); @@ -381,6 +386,7 @@ import zoneTo = require( '@stdlib/blas/ext/base/zone-to' ); import zreplicate = require( '@stdlib/blas/ext/base/zreplicate' ); import zsum = require( '@stdlib/blas/ext/base/zsum' ); import zsumkbn = require( '@stdlib/blas/ext/base/zsumkbn' ); +import ztriu = require( '@stdlib/blas/ext/base/ztriu' ); import zunitspace = require( '@stdlib/blas/ext/base/zunitspace' ); import zwapx = require( '@stdlib/blas/ext/base/zwapx' ); import zwax = require( '@stdlib/blas/ext/base/zwax' ); @@ -990,6 +996,39 @@ interface Namespace { */ csumkbn: typeof csumkbn; + /** + * Copies the upper triangular part of a single-precision complex 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 Complex64Array = require( '@stdlib/array/complex64' ); + * + * var A = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var B = new Complex64Array( 4 ); + * + * ns.ctriu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 7.0, 8.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var A = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var B = new Complex64Array( 4 ); + * + * ns.ctriu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 7.0, 8.0 ] + */ + ctriu: typeof ctriu; + /** * Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -4482,6 +4521,40 @@ interface Namespace { */ dwhere: typeof dwhere; + /** + * 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 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( [ 6.0, 12.0, 20.0, 30.0, 42.0 ] ); + * var y = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dwxdy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ 3.0, 4.0, 5.0, 6.0, 7.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 6.0, 12.0, 20.0, 30.0, 42.0 ] ); + * var y = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.dwxdy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ 3.0, 4.0, 5.0, 6.0, 7.0 ] + */ + dwxdy: typeof dwxdy; + /** * Multiplies 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 elements in a double-precision floating-point strided array `w`. * @@ -6017,6 +6090,34 @@ interface Namespace { */ gindexOfFalsy: typeof gindexOfFalsy; + /** + * Returns the index of the first row in an input matrix in which all elements are falsy. + * + * ## Notes + * + * - If the function is provided an empty matrix or if the function is unable to find a row in which all elements are falsy, the function returns `-1` (i.e., an invalid index). + * + * @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 of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @returns row index + * + * @example + * var A = [ 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0 ]; + * + * var out = ns.gindexOfFalsyRow( 'row-major', 4, 4, A, 4 ); + * // returns 1 + * + * @example + * var A = [ 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0 ]; + * + * var out = ns.gindexOfFalsyRow.ndarray( 4, 4, A, 4, 1, 0 ); + * // returns 1 + */ + gindexOfFalsyRow: typeof gindexOfFalsyRow; + /** * Returns the first index of an element in a strided array which is not equal to a specified search element. * @@ -8102,6 +8203,43 @@ interface Namespace { */ scircshift: typeof scircshift; + /** + * Performs an in-place copy of elements within a single-precision floating-point strided array. + * + * ## Notes + * + * - If the `start` and `target` index ranges do not overlap, the `workspace` array is unused and thus ignored. + * + * @param N - number of indexed elements + * @param target - target index + * @param start - source start index (inclusive) + * @param end - source end index (exclusive) + * @param x - input array + * @param strideX - stride length for `x` + * @param workspace - workspace array + * @param strideW - stride length for `workspace` + * @returns `x` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( x.length ); + * + * ns.scopyWithin( x.length, 3, 1, 4, x, 1, w, 1 ); + * // x => [ 1.0, 2.0, 3.0, 2.0, 3.0, 4.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var w = new Float32Array( x.length ); + * + * ns.scopyWithin.ndarray( x.length, 3, 1, 4, x, 1, 0, w, 1, 0 ); + * // x => [ 1.0, 2.0, 3.0, 2.0, 3.0, 4.0 ] + */ + scopyWithin: typeof scopyWithin; + /** * Cumulatively tests whether at least one element in a single-precision floating-point strided array is truthy. * @@ -10229,6 +10367,40 @@ interface Namespace { */ swhere: typeof swhere; + /** + * 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 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( [ 6.0, 12.0, 20.0, 30.0, 42.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.swxdy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ 3.0, 4.0, 5.0, 6.0, 7.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 6.0, 12.0, 20.0, 30.0, 42.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.swxdy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ 3.0, 4.0, 5.0, 6.0, 7.0 ] + */ + swxdy: typeof swxdy; + /** * 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`. * @@ -11306,6 +11478,39 @@ interface Namespace { */ zsumkbn: typeof zsumkbn; + /** + * Copies the upper triangular part of a double-precision complex 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 Complex128Array = require( '@stdlib/array/complex128' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var B = new Complex128Array( 4 ); + * + * ns.ztriu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 7.0, 8.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var B = new Complex128Array( 4 ); + * + * ns.ztriu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 7.0, 8.0 ] + */ + ztriu: typeof ztriu; + /** * Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. *