From 760b1da4ef421aa646fa3f93de06c5e593007ba2 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Fri, 14 Aug 2026 03:00:24 +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 | 237 ++++++++++++++++++ 1 file changed, 237 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 43ef38234769..a3f1f18daf2f 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 @@ -29,6 +29,7 @@ import cindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/cindex-of-truthy import coneTo = require( '@stdlib/blas/ext/base/ndarray/cone-to' ); import csum = require( '@stdlib/blas/ext/base/ndarray/csum' ); import csumkbn = require( '@stdlib/blas/ext/base/ndarray/csumkbn' ); +import ctril = require( '@stdlib/blas/ext/base/ndarray/ctril' ); import ctriu = require( '@stdlib/blas/ext/base/ndarray/ctriu' ); import cunitspace = require( '@stdlib/blas/ext/base/ndarray/cunitspace' ); import cwxsa = require( '@stdlib/blas/ext/base/ndarray/cwxsa' ); @@ -62,6 +63,7 @@ import dlastIndexEqual = require( '@stdlib/blas/ext/base/ndarray/dlast-index-equ import dlastIndexOf = require( '@stdlib/blas/ext/base/ndarray/dlast-index-of' ); import dlastIndexOfFalsy = require( '@stdlib/blas/ext/base/ndarray/dlast-index-of-falsy' ); import dlinspace = require( '@stdlib/blas/ext/base/ndarray/dlinspace' ); +import dlogspace = require( '@stdlib/blas/ext/base/ndarray/dlogspace' ); import dnansum = require( '@stdlib/blas/ext/base/ndarray/dnansum' ); import dnansumkbn = require( '@stdlib/blas/ext/base/ndarray/dnansumkbn' ); import dnansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dnansumkbn2' ); @@ -77,6 +79,7 @@ import dsumkbn = require( '@stdlib/blas/ext/base/ndarray/dsumkbn' ); 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 dtriu = require( '@stdlib/blas/ext/base/ndarray/dtriu' ); import dunitspace = require( '@stdlib/blas/ext/base/ndarray/dunitspace' ); import dwxsa = require( '@stdlib/blas/ext/base/ndarray/dwxsa' ); @@ -127,6 +130,7 @@ import gsumkbn = require( '@stdlib/blas/ext/base/ndarray/gsumkbn' ); 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 gtriu = require( '@stdlib/blas/ext/base/ndarray/gtriu' ); import gunitspace = require( '@stdlib/blas/ext/base/ndarray/gunitspace' ); import gwxsa = require( '@stdlib/blas/ext/base/ndarray/gwxsa' ); @@ -155,6 +159,7 @@ import sindexOf = require( '@stdlib/blas/ext/base/ndarray/sindex-of' ); import sindexOfNotEqual = require( '@stdlib/blas/ext/base/ndarray/sindex-of-not-equal' ); 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 snansum = require( '@stdlib/blas/ext/base/ndarray/snansum' ); import snansumkbn = require( '@stdlib/blas/ext/base/ndarray/snansumkbn' ); @@ -169,6 +174,7 @@ import ssumkbn = require( '@stdlib/blas/ext/base/ndarray/ssumkbn' ); import ssumkbn2 = require( '@stdlib/blas/ext/base/ndarray/ssumkbn2' ); 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 sunitspace = require( '@stdlib/blas/ext/base/ndarray/sunitspace' ); import swxsa = require( '@stdlib/blas/ext/base/ndarray/swxsa' ); @@ -186,6 +192,7 @@ import zindexOfTruthy = require( '@stdlib/blas/ext/base/ndarray/zindex-of-truthy import zoneTo = require( '@stdlib/blas/ext/base/ndarray/zone-to' ); import zsum = require( '@stdlib/blas/ext/base/ndarray/zsum' ); import zsumkbn = require( '@stdlib/blas/ext/base/ndarray/zsumkbn' ); +import ztril = require( '@stdlib/blas/ext/base/ndarray/ztril' ); import ztriu = require( '@stdlib/blas/ext/base/ndarray/ztriu' ); import zunitspace = require( '@stdlib/blas/ext/base/ndarray/zunitspace' ); import zwxsa = require( '@stdlib/blas/ext/base/ndarray/zwxsa' ); @@ -469,6 +476,39 @@ interface Namespace { */ csumkbn: typeof csumkbn; + /** + * Copies the lower triangular part of a single-precision complex floating-point matrix `A` to 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 Complex64Matrix = require( '@stdlib/ndarray/matrix/complex64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Complex64Matrix( [ [ 1.0, 2.0, 3.0, 4.0 ], [ 5.0, 6.0, 7.0, 8.0 ] ] ); + * var B = new Complex64Matrix( [ [ 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0 ] ] ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.ctril( [ A, B, k ] ); + * // returns [ [ [ 1.0, 2.0 ], [ 0.0, 0.0 ] ], [ [ 5.0, 6.0 ], [ 7.0, 8.0 ] ] ] + * + * var bool = ( out === B ); + * // returns true + */ + ctril: typeof ctril; + /** * Copies the upper triangular part of a single-precision complex floating-point matrix `A` to another matrix `B`. * @@ -1446,6 +1486,49 @@ interface Namespace { */ dlinspace: typeof dlinspace; + /** + * Fills a one-dimensional double-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 Float64Vector = require( '@stdlib/ndarray/vector/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var x = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * var base = scalar2ndarray( 10.0, { + * 'dtype': 'float64' + * }); + * + * var strt = scalar2ndarray( 0.0, { + * 'dtype': 'float64' + * }); + * + * var stp = scalar2ndarray( 5.0, { + * 'dtype': 'float64' + * }); + * + * var endpoint = scalar2ndarray( true, { + * 'dtype': 'bool' + * }); + * + * var out = ns.dlogspace( [ x, base, strt, stp, endpoint ] ); + * // returns [ 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0 ] + */ + dlogspace: typeof dlogspace; + /** * Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values. * @@ -1804,6 +1887,39 @@ interface Namespace { */ dsumpw: typeof dsumpw; + /** + * Copies the lower triangular part of a double-precision floating-point matrix `A` to 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.dtril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 3.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + dtril: typeof dtril; + /** * Copies the upper triangular part of a double-precision floating-point matrix `A` to another matrix `B`. * @@ -3185,6 +3301,39 @@ interface Namespace { */ gsumpw: typeof gsumpw; + /** + * Copies the lower triangular part of a matrix `A` to 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.gtril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 3.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + gtril: typeof gtril; + /** * Copies the upper triangular part of a matrix `A` to another matrix `B`. * @@ -4011,6 +4160,28 @@ interface Namespace { */ slastIndexOf: typeof slastIndexOf; + /** + * Returns the index of the last falsy element in a one-dimensional single-precision floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns index + * + * @example + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * + * var x = new Float32Vector( [ 1.0, 0.0, 3.0, 0.0 ] ); + * + * var v = ns.slastIndexOfFalsy( [ x ] ); + * // returns 3 + */ + slastIndexOfFalsy: typeof slastIndexOfFalsy; + /** * Fills a one-dimensional single-precision floating-point ndarray with linearly spaced values over a specified interval. * @@ -4355,6 +4526,39 @@ interface Namespace { */ ssumpw: typeof ssumpw; + /** + * Copies the lower triangular part of a single-precision floating-point matrix `A` to 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 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.stril( [ A, B, k ] ); + * // returns [ [ 1.0, 0.0 ], [ 3.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + stril: typeof stril; + /** * Copies the upper triangular part of a single-precision floating-point matrix `A` to another matrix `B`. * @@ -4821,6 +5025,39 @@ interface Namespace { */ zsumkbn: typeof zsumkbn; + /** + * Copies the lower triangular part of a double-precision complex floating-point matrix `A` to 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 Complex128Matrix = require( '@stdlib/ndarray/matrix/complex128' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Complex128Matrix( [ [ 1.0, 2.0, 3.0, 4.0 ], [ 5.0, 6.0, 7.0, 8.0 ] ] ); + * var B = new Complex128Matrix( [ [ 0.0, 0.0, 0.0, 0.0 ], [ 0.0, 0.0, 0.0, 0.0 ] ] ); + * + * var k = scalar2ndarray( 0, { + * 'dtype': 'generic' + * }); + * + * var out = ns.ztril( [ A, B, k ] ); + * // returns [ [ [ 1.0, 2.0 ], [ 0.0, 0.0 ] ], [ [ 5.0, 6.0 ], [ 7.0, 8.0 ] ] ] + * + * var bool = ( out === B ); + * // returns true + */ + ztril: typeof ztril; + /** * Copies the upper triangular part of a double-precision complex floating-point matrix `A` to another matrix `B`. *