From aa97e367ad036f74335aaaf4b8d303a76f4db45e Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Sat, 15 Aug 2026 02:28:09 +0000 Subject: [PATCH] feat: update `blas/ext/base/ndarray` TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../ext/base/ndarray/docs/types/index.d.ts | 258 ++++++++++++++++++ 1 file changed, 258 insertions(+) diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts index a3f1f18daf2f..904518914fd6 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts @@ -80,7 +80,9 @@ import dsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dsumkbn2' ); import dsumors = require( '@stdlib/blas/ext/base/ndarray/dsumors' ); import dsumpw = require( '@stdlib/blas/ext/base/ndarray/dsumpw' ); import dtril = require( '@stdlib/blas/ext/base/ndarray/dtril' ); +import dtril2triu = require( '@stdlib/blas/ext/base/ndarray/dtril2triu' ); import dtriu = require( '@stdlib/blas/ext/base/ndarray/dtriu' ); +import dtriu2tril = require( '@stdlib/blas/ext/base/ndarray/dtriu2tril' ); import dunitspace = require( '@stdlib/blas/ext/base/ndarray/dunitspace' ); import dwxsa = require( '@stdlib/blas/ext/base/ndarray/dwxsa' ); import dxdy = require( '@stdlib/blas/ext/base/ndarray/dxdy' ); @@ -117,6 +119,7 @@ import glastIndexEqual = require( '@stdlib/blas/ext/base/ndarray/glast-index-equ import glastIndexOf = require( '@stdlib/blas/ext/base/ndarray/glast-index-of' ); import glastIndexOfFalsy = require( '@stdlib/blas/ext/base/ndarray/glast-index-of-falsy' ); import glinspace = require( '@stdlib/blas/ext/base/ndarray/glinspace' ); +import glogspace = require( '@stdlib/blas/ext/base/ndarray/glogspace' ); import gnansum = require( '@stdlib/blas/ext/base/ndarray/gnansum' ); import gnansumkbn = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn' ); import gnansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn2' ); @@ -131,7 +134,9 @@ import gsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gsumkbn2' ); import gsumors = require( '@stdlib/blas/ext/base/ndarray/gsumors' ); import gsumpw = require( '@stdlib/blas/ext/base/ndarray/gsumpw' ); import gtril = require( '@stdlib/blas/ext/base/ndarray/gtril' ); +import gtril2triu = require( '@stdlib/blas/ext/base/ndarray/gtril2triu' ); import gtriu = require( '@stdlib/blas/ext/base/ndarray/gtriu' ); +import gtriu2tril = require( '@stdlib/blas/ext/base/ndarray/gtriu2tril' ); import gunitspace = require( '@stdlib/blas/ext/base/ndarray/gunitspace' ); import gwxsa = require( '@stdlib/blas/ext/base/ndarray/gwxsa' ); import gxdy = require( '@stdlib/blas/ext/base/ndarray/gxdy' ); @@ -161,6 +166,7 @@ import sindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/sindex-of-truthy import slastIndexOf = require( '@stdlib/blas/ext/base/ndarray/slast-index-of' ); import slastIndexOfFalsy = require( '@stdlib/blas/ext/base/ndarray/slast-index-of-falsy' ); import slinspace = require( '@stdlib/blas/ext/base/ndarray/slinspace' ); +import slogspace = require( '@stdlib/blas/ext/base/ndarray/slogspace' ); import snansum = require( '@stdlib/blas/ext/base/ndarray/snansum' ); import snansumkbn = require( '@stdlib/blas/ext/base/ndarray/snansumkbn' ); import snansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/snansumkbn2' ); @@ -176,6 +182,7 @@ import ssumors = require( '@stdlib/blas/ext/base/ndarray/ssumors' ); import ssumpw = require( '@stdlib/blas/ext/base/ndarray/ssumpw' ); import stril = require( '@stdlib/blas/ext/base/ndarray/stril' ); import striu = require( '@stdlib/blas/ext/base/ndarray/striu' ); +import striu2tril = require( '@stdlib/blas/ext/base/ndarray/striu2tril' ); import sunitspace = require( '@stdlib/blas/ext/base/ndarray/sunitspace' ); import swxsa = require( '@stdlib/blas/ext/base/ndarray/swxsa' ); import sxdy = require( '@stdlib/blas/ext/base/ndarray/sxdy' ); @@ -1920,6 +1927,39 @@ interface Namespace { */ dtril: typeof dtril; + /** + * Reflects the lower triangular part of a double-precision floating-point matrix `A` into the upper triangular part of another matrix `B`. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional output ndarray corresponding to `B`. + * - a zero-dimensional ndarray specifying the diagonal above which to ignore. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Matrix = require( '@stdlib/ndarray/matrix/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Float64Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * var B = new Float64Matrix( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ] ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.dtril2triu( [ A, B, k ] ); + * // returns [ [ 1.0, 3.0 ], [ 0.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + dtril2triu: typeof dtril2triu; + /** * Copies the upper triangular part of a double-precision floating-point matrix `A` to another matrix `B`. * @@ -1953,6 +1993,39 @@ interface Namespace { */ dtriu: typeof dtriu; + /** + * Reflects the upper triangular part of a double-precision floating-point matrix `A` into the lower triangular part of another matrix `B`. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional output ndarray corresponding to `B`. + * - a zero-dimensional ndarray specifying the diagonal below which to ignore. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Matrix = require( '@stdlib/ndarray/matrix/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Float64Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * var B = new Float64Matrix( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ] ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.dtriu2tril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 2.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + dtriu2tril: typeof dtriu2tril; + /** * Fills a one-dimensional double-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -2998,6 +3071,49 @@ interface Namespace { */ glinspace: typeof glinspace; + /** + * Fills a one-dimensional ndarray with logarithmically spaced values over a specified interval. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying the base of the logarithmic scale. + * - a zero-dimensional ndarray specifying the exponent of the starting value. + * - a zero-dimensional ndarray specifying the exponent of the final value. + * - a zero-dimensional ndarray specifying whether to include the `base^stop` value when writing values to the input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var vector = require( '@stdlib/ndarray/vector/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var x = vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], 'generic' ); + * + * var base = scalar2ndarray( 10.0, { + * 'dtype': 'generic' + * }); + * + * var strt = scalar2ndarray( 0.0, { + * 'dtype': 'generic' + * }); + * + * var stp = scalar2ndarray( 5.0, { + * 'dtype': 'generic' + * }); + * + * var endpoint = scalar2ndarray( true, { + * 'dtype': 'bool' + * }); + * + * var out = ns.glogspace( [ x, base, strt, stp, endpoint ] ); + * // returns [ 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0 ] + */ + glogspace: typeof glogspace; + /** * Computes the sum of a one-dimensional ndarray, ignoring `NaN` values. * @@ -3334,6 +3450,39 @@ interface Namespace { */ gtril: typeof gtril; + /** + * Reflects the lower triangular part of a matrix `A` into the upper triangular part of another matrix `B`. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional output ndarray corresponding to `B`. + * - a zero-dimensional ndarray specifying the diagonal above which to ignore. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var matrix = require( '@stdlib/ndarray/matrix/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], 'generic' ); + * var B = matrix( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ], 'generic' ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.gtril2triu( [ A, B, k ] ); + * // returns [ [ 1.0, 3.0 ], [ 0.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + gtril2triu: typeof gtril2triu; + /** * Copies the upper triangular part of a matrix `A` to another matrix `B`. * @@ -3367,6 +3516,39 @@ interface Namespace { */ gtriu: typeof gtriu; + /** + * Reflects the upper triangular part of a matrix `A` into the lower triangular part of another matrix `B`. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional output ndarray corresponding to `B`. + * - a zero-dimensional ndarray specifying the diagonal below which to ignore. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var matrix = require( '@stdlib/ndarray/matrix/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], 'generic' ); + * var B = matrix( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ], 'generic' ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.gtriu2tril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 2.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + gtriu2tril: typeof gtriu2tril; + /** * Fills a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -4220,6 +4402,49 @@ interface Namespace { */ slinspace: typeof slinspace; + /** + * Fills a one-dimensional single-precision floating-point ndarray with logarithmically spaced values over a specified interval. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying the base of the logarithmic scale. + * - a zero-dimensional ndarray specifying the exponent of the starting value. + * - a zero-dimensional ndarray specifying the exponent of the final value. + * - a zero-dimensional ndarray specifying whether to include the `base^stop` value when writing values to the input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns input ndarray + * + * @example + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var x = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * var base = scalar2ndarray( 10.0, { + * 'dtype': 'float32' + * }); + * + * var strt = scalar2ndarray( 0.0, { + * 'dtype': 'float32' + * }); + * + * var stp = scalar2ndarray( 5.0, { + * 'dtype': 'float32' + * }); + * + * var endpoint = scalar2ndarray( true, { + * 'dtype': 'bool' + * }); + * + * var out = ns.slogspace( [ x, base, strt, stp, endpoint ] ); + * // returns [ 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0 ] + */ + slogspace: typeof slogspace; + /** * Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. * @@ -4592,6 +4817,39 @@ interface Namespace { */ striu: typeof striu; + /** + * Reflects the upper triangular part of a single-precision floating-point matrix `A` into the lower triangular part of another matrix `B`. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional output ndarray corresponding to `B`. + * - a zero-dimensional ndarray specifying the diagonal below which to ignore. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float32Matrix = require( '@stdlib/ndarray/matrix/float32' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Float32Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * var B = new Float32Matrix( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ] ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.striu2tril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 2.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + striu2tril: typeof striu2tril; + /** * Fills a one-dimensional single-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. *