From 3d0315322b6e92d27d8c1c6e8c8d1488de15bfd1 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Tue, 29 Sep 2026 02:26:12 +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 | 404 ++++++++++++++++++ 1 file changed, 404 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 b851ab0f19a1..840f9ffe0bb3 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 @@ -40,6 +40,7 @@ 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 ctril = require( '@stdlib/blas/ext/base/ctril' ); +import ctril2triu = require( '@stdlib/blas/ext/base/ctril2triu' ); import ctriu = require( '@stdlib/blas/ext/base/ctriu' ); import ctriu2tril = require( '@stdlib/blas/ext/base/ctriu2tril' ); import cunitspace = require( '@stdlib/blas/ext/base/cunitspace' ); @@ -99,6 +100,7 @@ import dlastIndexOf = require( '@stdlib/blas/ext/base/dlast-index-of' ); import dlastIndexOfFalsy = require( '@stdlib/blas/ext/base/dlast-index-of-falsy' ); import dlastIndexOfRow = require( '@stdlib/blas/ext/base/dlast-index-of-row' ); import dlastIndexOfTruthy = require( '@stdlib/blas/ext/base/dlast-index-of-truthy' ); +import dleftPadEdge = require( '@stdlib/blas/ext/base/dleft-pad-edge' ); 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' ); @@ -204,10 +206,12 @@ import gfillEqual = require( '@stdlib/blas/ext/base/gfill-equal' ); import gfillGreaterThan = require( '@stdlib/blas/ext/base/gfill-greater-than' ); import gfillGreaterThanEqual = require( '@stdlib/blas/ext/base/gfill-greater-than-equal' ); import gfillLessThan = require( '@stdlib/blas/ext/base/gfill-less-than' ); +import gfillLessThanEqual = require( '@stdlib/blas/ext/base/gfill-less-than-equal' ); import gfillNaN = require( '@stdlib/blas/ext/base/gfill-nan' ); import gfillNotEqual = require( '@stdlib/blas/ext/base/gfill-not-equal' ); import gfindIndex = require( '@stdlib/blas/ext/base/gfind-index' ); import gfindLastIndex = require( '@stdlib/blas/ext/base/gfind-last-index' ); +import gfirstIndexAlmostEqual = require( '@stdlib/blas/ext/base/gfirst-index-almost-equal' ); import gfirstIndexAlmostSameValue = require( '@stdlib/blas/ext/base/gfirst-index-almost-same-value' ); import gfirstIndexEqual = require( '@stdlib/blas/ext/base/gfirst-index-equal' ); import gfirstIndexGreaterThan = require( '@stdlib/blas/ext/base/gfirst-index-greater-than' ); @@ -231,8 +235,13 @@ import gindexOfTruthy = require( '@stdlib/blas/ext/base/gindex-of-truthy' ); import gindexOfTruthyRow = require( '@stdlib/blas/ext/base/gindex-of-truthy-row' ); import gjoin = require( '@stdlib/blas/ext/base/gjoin' ); import gjoinBetween = require( '@stdlib/blas/ext/base/gjoin-between' ); +import glastIndexAlmostSameValue = require( '@stdlib/blas/ext/base/glast-index-almost-same-value' ); import glastIndexEqual = require( '@stdlib/blas/ext/base/glast-index-equal' ); +import glastIndexGreaterThan = require( '@stdlib/blas/ext/base/glast-index-greater-than' ); +import glastIndexGreaterThanEqual = require( '@stdlib/blas/ext/base/glast-index-greater-than-equal' ); import glastIndexLessThan = require( '@stdlib/blas/ext/base/glast-index-less-than' ); +import glastIndexLessThanEqual = require( '@stdlib/blas/ext/base/glast-index-less-than-equal' ); +import glastIndexNotEqual = require( '@stdlib/blas/ext/base/glast-index-not-equal' ); import glastIndexOf = require( '@stdlib/blas/ext/base/glast-index-of' ); import glastIndexOfFalsy = require( '@stdlib/blas/ext/base/glast-index-of-falsy' ); import glastIndexOfRow = require( '@stdlib/blas/ext/base/glast-index-of-row' ); @@ -254,9 +263,11 @@ import gnansumors = require( '@stdlib/blas/ext/base/gnansumors' ); import gnansumpw = require( '@stdlib/blas/ext/base/gnansumpw' ); import gnone = require( '@stdlib/blas/ext/base/gnone' ); import goneTo = require( '@stdlib/blas/ext/base/gone-to' ); +import gpadEdge = require( '@stdlib/blas/ext/base/gpad-edge' ); import greplicate = require( '@stdlib/blas/ext/base/greplicate' ); import grev = require( '@stdlib/blas/ext/base/grev' ); import grightPadCircular = require( '@stdlib/blas/ext/base/gright-pad-circular' ); +import grightPadEdge = require( '@stdlib/blas/ext/base/gright-pad-edge' ); import gsome = require( '@stdlib/blas/ext/base/gsome' ); import gsort = require( '@stdlib/blas/ext/base/gsort' ); import gsort2hp = require( '@stdlib/blas/ext/base/gsort2hp' ); @@ -416,7 +427,9 @@ 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 ztril = require( '@stdlib/blas/ext/base/ztril' ); +import ztril2triu = require( '@stdlib/blas/ext/base/ztril2triu' ); import ztriu = require( '@stdlib/blas/ext/base/ztriu' ); +import ztriu2tril = require( '@stdlib/blas/ext/base/ztriu2tril' ); import zunitspace = require( '@stdlib/blas/ext/base/zunitspace' ); import zwapx = require( '@stdlib/blas/ext/base/zwapx' ); import zwax = require( '@stdlib/blas/ext/base/zwax' ); @@ -1191,6 +1204,39 @@ interface Namespace { */ ctril: typeof ctril; + /** + * Reflects the lower triangular part of a single-precision complex floating-point matrix `A` into the upper triangular part of 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 above 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.ctril2triu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 5.0, 6.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.ctril2triu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 5.0, 6.0, 0.0, 0.0, 7.0, 8.0 ] + */ + ctril2triu: typeof ctril2triu; + /** * Copies the upper triangular part of a single-precision complex floating-point matrix `A` to another matrix `B`. * @@ -3093,6 +3139,37 @@ interface Namespace { */ dlastIndexOfTruthy: typeof dlastIndexOfTruthy; + /** + * Prepends elements to a double-precision floating-point strided array by repeating the leading edge element. + * + * @param N - number of indexed elements in `x` + * @param k - number of elements to pad + * @param x - input array + * @param strideX - stride length for `x` + * @param y - output array + * @param strideY - stride length for `y` + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float64Array( 10 ); + * + * ns.dleftPadEdge( x.length, 6, x, 1, y, 1 ); + * // y => [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 3.0, 4.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Float64Array( 10 ); + * + * ns.dleftPadEdge.ndarray( x.length, 6, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 3.0, 4.0 ] + */ + dleftPadEdge: typeof dleftPadEdge; + /** * Fills a double-precision floating-point strided array with linearly spaced values over a specified interval. * @@ -6128,6 +6205,30 @@ interface Namespace { */ gfillLessThan: typeof gfillLessThan; + /** + * Replaces strided array elements less than or equal to a provided search element with a specified scalar constant. + * + * @param N - number of indexed elements + * @param searchElement - search element + * @param alpha - scalar constant + * @param x - input array + * @param strideX - stride length + * @returns `x` + * + * @example + * var x = [ 0.0, 0.0, 1.0, 0.0 ]; + * + * ns.gfillLessThanEqual( x.length, 0.0, 5.0, x, 1 ); + * // x => [ 5.0, 5.0, 1.0, 5.0 ] + * + * @example + * var x = [ 0.0, 0.0, 1.0, 0.0 ]; + * + * ns.gfillLessThanEqual.ndarray( x.length, 0.0, 5.0, x, 1, 0 ); + * // x => [ 5.0, 5.0, 1.0, 5.0 ] + */ + gfillLessThanEqual: typeof gfillLessThanEqual; + /** * Replaces strided array elements equal to `NaN` with a specified scalar constant. * @@ -6261,6 +6362,37 @@ interface Namespace { */ gfindLastIndex: typeof gfindLastIndex; + /** + * Returns the index of the first element in a strided array which is almost equal to a corresponding element in another strided array. + * + * ## Notes + * + * - If the function is unable to find matching elements, the function returns `-1`. + * + * @param N - number of indexed elements + * @param maxULP - maximum allowed ULP difference + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.gfirstIndexAlmostEqual( x.length, 1, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.gfirstIndexAlmostEqual.ndarray( x.length, 1, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + gfirstIndexAlmostEqual: typeof gfirstIndexAlmostEqual; + /** * Returns the index of the first element in a strided array which is almost the same value as a corresponding element in another strided array. * @@ -6912,6 +7044,37 @@ interface Namespace { */ gjoinBetween: typeof gjoinBetween; + /** + * Returns the index of the last element in a strided array which is almost the same value as a corresponding element in another strided array. + * + * ## Notes + * + * - If the function is unable to find matching elements, the function returns `-1`. + * + * @param N - number of indexed elements + * @param maxULP - maximum allowed ULP difference + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.glastIndexAlmostSameValue( x.length, 1, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.glastIndexAlmostSameValue.ndarray( x.length, 1, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + glastIndexAlmostSameValue: typeof glastIndexAlmostSameValue; + /** * Returns the index of the last element in a strided array equal to a corresponding element in another strided array. * @@ -6942,6 +7105,66 @@ interface Namespace { */ glastIndexEqual: typeof glastIndexEqual; + /** + * Returns the index of the last element in a strided array which is greater than a corresponding element in another strided array. + * + * ## Notes + * + * - If the function is unable to find an element in `x` which is greater than a corresponding element in `y`, the function returns `-1`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 0.0, 0.0, 1.0, 0.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * var idx = ns.glastIndexGreaterThan( x.length, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var x = [ 0.0, 0.0, 1.0, 0.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0 ]; + * + * var idx = ns.glastIndexGreaterThan.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + glastIndexGreaterThan: typeof glastIndexGreaterThan; + + /** + * Returns the index of the last element in a strided array which is greater than or equal to a corresponding element in another strided array. + * + * ## Notes + * + * - If the function is unable to find an element in `x` which is greater than or equal to a corresponding element in `y`, the function returns `-1`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 2.0, 2.0, 2.0, 5.0 ]; + * + * var idx = ns.glastIndexGreaterThanEqual( x.length, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 2.0, 2.0, 2.0, 5.0 ]; + * + * var idx = ns.glastIndexGreaterThanEqual.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + glastIndexGreaterThanEqual: typeof glastIndexGreaterThanEqual; + /** * Returns the index of the last element in a strided array which is less than a corresponding element in another strided array. * @@ -6972,6 +7195,66 @@ interface Namespace { */ glastIndexLessThan: typeof glastIndexLessThan; + /** + * Returns the index of the last element in a strided array which is less than or equal to a corresponding element in another strided array. + * + * ## Notes + * + * - If the function is unable to find an element in `x` which is less than or equal to a corresponding element in `y`, the function returns `-1`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 3.0, 5.0, 4.0, 6.0 ]; + * var y = [ 2.0, 4.0, 4.0, 5.0 ]; + * + * var idx = ns.glastIndexLessThanEqual( x.length, x, 1, y, 1 ); + * // returns 2 + * + * @example + * var x = [ 3.0, 5.0, 4.0, 6.0 ]; + * var y = [ 2.0, 4.0, 4.0, 5.0 ]; + * + * var idx = ns.glastIndexLessThanEqual.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns 2 + */ + glastIndexLessThanEqual: typeof glastIndexLessThanEqual; + + /** + * Returns the index of the last element in a strided array which is not equal to the corresponding element in another strided array. + * + * ## Notes + * + * - If unable to find an element in `x` which is not equal to the corresponding element in `y`, the function returns `-1`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - stride length for `x` + * @param y - second input array + * @param strideY - stride length for `y` + * @returns index + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.glastIndexNotEqual( x.length, x, 1, y, 1 ); + * // returns 3 + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 3.0, 0.0 ]; + * + * var idx = ns.glastIndexNotEqual.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns 3 + */ + glastIndexNotEqual: typeof glastIndexNotEqual; + /** * Returns the last index of a specified search element in a strided array. * @@ -7526,6 +7809,34 @@ interface Namespace { */ goneTo: typeof goneTo; + /** + * Pads a strided array by repeating leading and trailing edge elements. + * + * @param N - number of indexed elements in `x` + * @param j - number of elements to pad on the leading edge + * @param k - number of elements to pad on the trailing edge + * @param x - input array + * @param strideX - stride length for `x` + * @param y - output array + * @param strideY - stride length for `y` + * @returns output array + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gpadEdge( x.length, 1, 1, x, 1, y, 1 ); + * // y => [ 1.0, 1.0, 2.0, 3.0, 4.0, 4.0 ] + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.gpadEdge.ndarray( x.length, 1, 1, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 1.0, 2.0, 3.0, 4.0, 4.0 ] + */ + gpadEdge: typeof gpadEdge; + /** * Replicates each strided array element a specified number of times. * @@ -7602,6 +7913,33 @@ interface Namespace { */ grightPadCircular: typeof grightPadCircular; + /** + * Appends elements to a strided array by repeating the trailing edge element. + * + * @param N - number of indexed elements in `x` + * @param k - number of elements to pad + * @param x - input array + * @param strideX - stride length for `x` + * @param y - output array + * @param strideY - stride length for `y` + * @returns output array + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.grightPadEdge( x.length, 6, x, 1, y, 1 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] + * + * @example + * var x = [ 1.0, 2.0, 3.0, 4.0 ]; + * var y = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]; + * + * ns.grightPadEdge.ndarray( x.length, 6, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] + */ + grightPadEdge: typeof grightPadEdge; + /** * Tests whether a strided array contains at least `k` truthy elements. * @@ -12481,6 +12819,39 @@ interface Namespace { */ ztril: typeof ztril; + /** + * Reflects the lower triangular part of a double-precision complex floating-point matrix `A` into the upper triangular part of 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 above 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.ztril2triu( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 5.0, 6.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.ztril2triu.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 5.0, 6.0, 0.0, 0.0, 7.0, 8.0 ] + */ + ztril2triu: typeof ztril2triu; + /** * Copies the upper triangular part of a double-precision complex floating-point matrix `A` to another matrix `B`. * @@ -12514,6 +12885,39 @@ interface Namespace { */ ztriu: typeof ztriu; + /** + * Reflects the upper triangular part of a double-precision complex floating-point matrix `A` into the lower triangular part of 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.ztriu2tril( 'row-major', 2, 2, 0, A, 2, B, 2 ); + * // B => [ 1.0, 2.0, 0.0, 0.0, 3.0, 4.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.ztriu2tril.ndarray( 2, 2, 0, A, 2, 1, 0, B, 2, 1, 0 ); + * // B => [ 1.0, 2.0, 0.0, 0.0, 3.0, 4.0, 7.0, 8.0 ] + */ + ztriu2tril: typeof ztriu2tril; + /** * Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from a specified value. *