From 608adeec9cea65f7ddef83c50819efeb903baaaf Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Tue, 28 Jul 2026 03:11:31 +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 | 165 ++++++++++++++++++ 1 file changed, 165 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 5e874001469f..42d8b76358bb 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 @@ -87,6 +87,7 @@ import dlastIndexOfTruthy = require( '@stdlib/blas/ext/base/dlast-index-of-truth import dlinspace = require( '@stdlib/blas/ext/base/dlinspace' ); import dlogspace = require( '@stdlib/blas/ext/base/dlogspace' ); import dminheapSiftDown = require( '@stdlib/blas/ext/base/dminheap-sift-down' ); +import dminheapify = require( '@stdlib/blas/ext/base/dminheapify' ); import dmskrev = require( '@stdlib/blas/ext/base/dmskrev' ); import dnanasum = require( '@stdlib/blas/ext/base/dnanasum' ); import dnanasumors = require( '@stdlib/blas/ext/base/dnanasumors' ); @@ -229,12 +230,14 @@ import gsumkbn = require( '@stdlib/blas/ext/base/gsumkbn' ); import gsumkbn2 = require( '@stdlib/blas/ext/base/gsumkbn2' ); import gsumors = require( '@stdlib/blas/ext/base/gsumors' ); import gsumpw = require( '@stdlib/blas/ext/base/gsumpw' ); +import gtriu = require( '@stdlib/blas/ext/base/gtriu' ); import gunitspace = require( '@stdlib/blas/ext/base/gunitspace' ); import gvander = require( '@stdlib/blas/ext/base/gvander' ); import gwapx = require( '@stdlib/blas/ext/base/gwapx' ); import gwax = require( '@stdlib/blas/ext/base/gwax' ); import gwaxpb = require( '@stdlib/blas/ext/base/gwaxpb' ); import gwhere = require( '@stdlib/blas/ext/base/gwhere' ); +import gwxmy = require( '@stdlib/blas/ext/base/gwxmy' ); import gwxpy = require( '@stdlib/blas/ext/base/gwxpy' ); import gwxsa = require( '@stdlib/blas/ext/base/gwxsa' ); import gwxsy = require( '@stdlib/blas/ext/base/gwxsy' ); @@ -336,6 +339,8 @@ import wasm = require( '@stdlib/blas/ext/base/wasm' ); import zapx = require( '@stdlib/blas/ext/base/zapx' ); import zaxpb = require( '@stdlib/blas/ext/base/zaxpb' ); import zaxpby = require( '@stdlib/blas/ext/base/zaxpby' ); +import zcartesianProduct = require( '@stdlib/blas/ext/base/zcartesian-product' ); +import zcartesianSquare = require( '@stdlib/blas/ext/base/zcartesian-square' ); 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' ); @@ -2588,6 +2593,36 @@ interface Namespace { */ dminheapSiftDown: typeof dminheapSiftDown; + /** + * Converts a double-precision floating-point strided array to a min-heap. + * + * ## Notes + * + * - The min-heap algorithm is sensitive to the presence of `NaN` values. Since `NaN` comparisons always return `false`, if `NaN` values are present in the input array, the results may be unpredictable. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns input array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 7.0, 5.0, 3.0, 1.0, 9.0 ] ); + * + * ns.dminheapify( 5, x, 1 ); + * // x => [ 1.0, 5.0, 3.0, 7.0, 9.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 7.0, 0.0, 5.0, 0.0, 3.0, 0.0, 1.0, 0.0, 9.0 ] ); + * + * ns.dminheapify.ndarray( 5, x, 2, 0 ); + * // x => [ 1.0, 0.0, 5.0, 0.0, 3.0, 0.0, 7.0, 0.0, 9.0 ] + */ + dminheapify: typeof dminheapify; + /** * Reverses a double-precision floating-point strided array in-place according to a mask. * @@ -6536,6 +6571,35 @@ interface Namespace { */ gsumpw: typeof gsumpw; + /** + * Copies the upper triangular part of a 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 A = [ 1.0, 2.0, 3.0, 4.0 ]; + * var B = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gtriu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + * + * @example + * var A = [ 1.0, 2.0, 3.0, 4.0 ]; + * var B = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gtriu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 0.0, 4.0 ] + */ + gtriu: typeof gtriu; + /** * Fills a strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -6704,6 +6768,36 @@ interface Namespace { */ gwhere: typeof gwhere; + /** + * Multiplies elements of a strided array `x` by the corresponding elements of a strided array `y` and assigns the results to elements in a 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 x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ]; + * var y = [ 2.0, 3.0, 4.0, 5.0, 6.0 ]; + * var w = [ 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gwxmy( x.length, x, 1, y, 1, w, 1 ); + * // w => [ 2.0, 6.0, 12.0, 20.0, 30.0 ] + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ]; + * var y = [ 2.0, 3.0, 4.0, 5.0, 6.0 ]; + * var w = [ 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gwxmy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 ); + * // w => [ 2.0, 6.0, 12.0, 20.0, 30.0 ] + */ + gwxmy: typeof gwxmy; + /** * Adds elements of a strided array `x` to the corresponding elements of a strided array `y` and assigns the results to elements in a strided array `w`. * @@ -9727,6 +9821,77 @@ interface Namespace { */ zaxpby: typeof zaxpby; + /** + * Computes the Cartesian product for two double-precision complex floating-point strided arrays. + * + * ## Notes + * + * - Pairs are stored as rows in the output matrix, where the first column contains the first element of each pair and the second column contains the second element. + * + * @param order - storage layout + * @param M - number of indexed elements in `x` + * @param N - number of indexed elements in `y` + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @param out - output array + * @param LDO - stride length between successive contiguous vectors of the matrix `out` (a.k.a., leading dimension of `out`) + * @returns output array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex128Array( [ 5.0, 6.0, 7.0, 8.0 ] ); + * var out = new Complex128Array( 8 ); + * + * ns.zcartesianProduct( 'row-major', x.length, y.length, x, 1, y, 1, out, 2 ); + * // out => [ 1.0, 2.0, 5.0, 6.0, 1.0, 2.0, 7.0, 8.0, 3.0, 4.0, 5.0, 6.0, 3.0, 4.0, 7.0, 8.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex128Array( [ 5.0, 6.0, 7.0, 8.0 ] ); + * var out = new Complex128Array( 8 ); + * + * ns.zcartesianProduct.ndarray( x.length, y.length, x, 1, 0, y, 1, 0, out, 2, 1, 0 ); + * // out => [ 1.0, 2.0, 5.0, 6.0, 1.0, 2.0, 7.0, 8.0, 3.0, 4.0, 5.0, 6.0, 3.0, 4.0, 7.0, 8.0 ] + */ + zcartesianProduct: typeof zcartesianProduct; + + /** + * Computes the Cartesian square for a double-precision complex floating-point strided array. + * + * @param order - storage layout + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @param out - output array + * @param LDO - stride length between successive contiguous vectors of the matrix `out` (a.k.a., leading dimension of `out`) + * @returns output array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var out = new Complex128Array( 8 ); + * + * ns.zcartesianSquare( 'row-major', x.length, x, 1, out, 2 ); + * // out => [ 1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var out = new Complex128Array( 8 ); + * + * ns.zcartesianSquare.ndarray( x.length, x, 1, 0, out, 2, 1, 0 ); + * // out => [ 1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0 ] + */ + zcartesianSquare: typeof zcartesianSquare; + /** * Calculates the k-th discrete forward difference of a double-precision complex floating-point strided array. *