From 24df28d215f8869ed1b2c7a62ba3c56cf332a3b9 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Mon, 10 Aug 2026 02:53:17 +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 | 170 ++++++++++++++++++ 1 file changed, 170 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 3390e43f0ce0..de73cb6a6ddf 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 @@ -27,6 +27,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 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' ); import cxmy = require( '@stdlib/blas/ext/base/ndarray/cxmy' ); @@ -71,6 +72,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 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' ); import dxdy = require( '@stdlib/blas/ext/base/ndarray/dxdy' ); @@ -117,6 +119,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 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' ); import gxdy = require( '@stdlib/blas/ext/base/ndarray/gxdy' ); @@ -155,6 +158,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 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' ); import sxdy = require( '@stdlib/blas/ext/base/ndarray/sxdy' ); @@ -170,6 +174,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 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' ); import zxdy = require( '@stdlib/blas/ext/base/ndarray/zxdy' ); @@ -375,6 +380,39 @@ interface Namespace { */ csumkbn: typeof csumkbn; + /** + * Copies the upper 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 below 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.ctriu( [ A, B, k ] ); + * // returns [ [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], [ [ 0.0, 0.0 ], [ 7.0, 8.0 ] ] ] + * + * var bool = ( out === B ); + * // returns true + */ + ctriu: typeof ctriu; + /** * Fills a one-dimensional single-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -1601,6 +1639,39 @@ interface Namespace { */ dsumpw: typeof dsumpw; + /** + * Copies the upper 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 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.dtriu( [ A, B, k ] ); + * // returns [ [ 1.0, 2.0 ], [ 0.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + dtriu: typeof dtriu; + /** * Fills a one-dimensional double-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -2873,6 +2944,39 @@ interface Namespace { */ gsumpw: typeof gsumpw; + /** + * Copies the upper 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 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.gtriu( [ A, B, k ] ); + * // returns [ [ 1.0, 2.0 ], [ 0.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + gtriu: typeof gtriu; + /** * Fills a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -3921,6 +4025,39 @@ interface Namespace { */ ssumpw: typeof ssumpw; + /** + * Copies the upper 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 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.striu( [ A, B, k ] ); + * // returns [ [ 1.0, 2.0 ], [ 0.0, 4.0 ] ] + * + * var bool = ( out === B ); + * // returns true + */ + striu: typeof striu; + /** * Fills a one-dimensional single-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. * @@ -4313,6 +4450,39 @@ interface Namespace { */ zsumkbn: typeof zsumkbn; + /** + * Copies the upper 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 below 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.ztriu( [ A, B, k ] ); + * // returns [ [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], [ [ 0.0, 0.0 ], [ 7.0, 8.0 ] ] ] + * + * var bool = ( out === B ); + * // returns true + */ + ztriu: typeof ztriu; + /** * Fills a one-dimensional double-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value. *