From 3fc2fe368e9e3128649e13793a0fcc971398d9a7 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Mon, 20 Jul 2026 03:12:56 +0000 Subject: [PATCH] feat: update `blas/base/ndarray` TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../blas/base/ndarray/docs/types/index.d.ts | 351 ++++++++++++++++++ 1 file changed, 351 insertions(+) diff --git a/lib/node_modules/@stdlib/blas/base/ndarray/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/ndarray/docs/types/index.d.ts index 6b3da7b43df4..dc5366bc9425 100644 --- a/lib/node_modules/@stdlib/blas/base/ndarray/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/ndarray/docs/types/index.d.ts @@ -30,6 +30,7 @@ import dasum = require( '@stdlib/blas/base/ndarray/dasum' ); import daxpy = require( '@stdlib/blas/base/ndarray/daxpy' ); import dcopy = require( '@stdlib/blas/base/ndarray/dcopy' ); import ddot = require( '@stdlib/blas/base/ndarray/ddot' ); +import dgemm = require( '@stdlib/blas/base/ndarray/dgemm' ); import dgemv = require( '@stdlib/blas/base/ndarray/dgemv' ); import dger = require( '@stdlib/blas/base/ndarray/dger' ); import dnrm2 = require( '@stdlib/blas/base/ndarray/dnrm2' ); @@ -37,17 +38,21 @@ import dscal = require( '@stdlib/blas/base/ndarray/dscal' ); import dsdot = require( '@stdlib/blas/base/ndarray/dsdot' ); import dspr = require( '@stdlib/blas/base/ndarray/dspr' ); import dswap = require( '@stdlib/blas/base/ndarray/dswap' ); +import dsyr = require( '@stdlib/blas/base/ndarray/dsyr' ); +import dsyr2 = require( '@stdlib/blas/base/ndarray/dsyr2' ); import dzasum = require( '@stdlib/blas/base/ndarray/dzasum' ); import dznrm2 = require( '@stdlib/blas/base/ndarray/dznrm2' ); import gasum = require( '@stdlib/blas/base/ndarray/gasum' ); import gaxpy = require( '@stdlib/blas/base/ndarray/gaxpy' ); import gcopy = require( '@stdlib/blas/base/ndarray/gcopy' ); import gdot = require( '@stdlib/blas/base/ndarray/gdot' ); +import ggemm = require( '@stdlib/blas/base/ndarray/ggemm' ); import ggemv = require( '@stdlib/blas/base/ndarray/ggemv' ); import gger = require( '@stdlib/blas/base/ndarray/gger' ); import gnrm2 = require( '@stdlib/blas/base/ndarray/gnrm2' ); import gscal = require( '@stdlib/blas/base/ndarray/gscal' ); import gswap = require( '@stdlib/blas/base/ndarray/gswap' ); +import gsyr = require( '@stdlib/blas/base/ndarray/gsyr' ); import idamax = require( '@stdlib/blas/base/ndarray/idamax' ); import igamax = require( '@stdlib/blas/base/ndarray/igamax' ); import isamax = require( '@stdlib/blas/base/ndarray/isamax' ); @@ -58,12 +63,15 @@ import scnrm2 = require( '@stdlib/blas/base/ndarray/scnrm2' ); import scopy = require( '@stdlib/blas/base/ndarray/scopy' ); import sdot = require( '@stdlib/blas/base/ndarray/sdot' ); import sdsdot = require( '@stdlib/blas/base/ndarray/sdsdot' ); +import sgemm = require( '@stdlib/blas/base/ndarray/sgemm' ); import sgemv = require( '@stdlib/blas/base/ndarray/sgemv' ); import sger = require( '@stdlib/blas/base/ndarray/sger' ); import snrm2 = require( '@stdlib/blas/base/ndarray/snrm2' ); import sscal = require( '@stdlib/blas/base/ndarray/sscal' ); import sspr = require( '@stdlib/blas/base/ndarray/sspr' ); import sswap = require( '@stdlib/blas/base/ndarray/sswap' ); +import ssyr = require( '@stdlib/blas/base/ndarray/ssyr' ); +import ssyr2 = require( '@stdlib/blas/base/ndarray/ssyr2' ); import zaxpy = require( '@stdlib/blas/base/ndarray/zaxpy' ); import zcopy = require( '@stdlib/blas/base/ndarray/zcopy' ); import zdscal = require( '@stdlib/blas/base/ndarray/zdscal' ); @@ -378,6 +386,54 @@ interface Namespace { */ ddot: typeof ddot; + /** + * Performs the matrix-matrix operation `C = alpha*op(A)*op(B) + beta*C`, where `op(X)` is either `op(X) = X` or `op(X) = X^T`, `alpha` and `beta` are scalars, `A`, `B`, and `C` are matrices, with `op(A)` an `M` by `K` matrix, `op(B)` a `K` by `N` matrix, and `C` an `M` by `N` matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional input ndarray corresponding to `B`. + * - a two-dimensional input/output ndarray corresponding to `C`. + * - a zero-dimensional ndarray specifying whether `A` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray specifying whether `B` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `beta`. + * + * @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 resolveEnum = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); + * + * var A = new Float64Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * var B = new Float64Matrix( [ [ 1.0, 1.0 ], [ 0.0, 1.0 ] ] ); + * var C = new Float64Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * + * var transA = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var transB = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 1.0, { + * 'dtype': 'float64' + * }); + * var beta = scalar2ndarray( 1.0, { + * 'dtype': 'float64' + * }); + * + * var z = ns.dgemm( [ A, B, C, transA, transB, alpha, beta ] ); + * // returns [ [ 2.0, 5.0 ], [ 6.0, 11.0 ] ] + * + * var bool = ( z === C ); + * // returns true + */ + dgemm: typeof dgemm; + /** * Performs one of the matrix-vector operations `y = alpha*A*x + beta*y` or `y = alpha*A^T*x + beta*y`, where `alpha` and `beta` are scalars, `x` and `y` are one-dimensional ndarrays, and `A` is an `M` by `N` matrix. * @@ -602,6 +658,86 @@ interface Namespace { */ dswap: typeof dswap; + /** + * Performs the symmetric rank 1 operation `A = alpha*x*x^T + A`, where `alpha` is a scalar, `x` is a one-dimensional ndarray, and `A` is an `N` by `N` symmetric matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray corresponding to `x`. + * - a two-dimensional input/output ndarray corresponding to `A`. + * - a zero-dimensional ndarray specifying whether the upper or lower triangular part of the symmetric matrix `A` should be referenced. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Matrix = require( '@stdlib/ndarray/matrix/float64' ); + * var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var resolveEnum = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' ); + * + * var x = new Float64Vector( [ 1.0, 2.0, 3.0 ] ); + * var A = new Float64Matrix( [ [ 1.0, 2.0, 3.0 ], [ 2.0, 1.0, 2.0 ], [ 3.0, 2.0, 1.0 ] ] ); + * + * var uplo = scalar2ndarray( resolveEnum( 'upper' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 1.0, { + * 'dtype': 'float64' + * }); + * + * var y = ns.dsyr( [ x, A, uplo, alpha ] ); + * // returns [ [ 2.0, 4.0, 6.0 ], [ 2.0, 5.0, 8.0 ], [ 3.0, 2.0, 10.0 ] ] + * + * var bool = ( y === A ); + * // returns true + */ + dsyr: typeof dsyr; + + /** + * Performs the symmetric rank 2 operation `A = alpha*x*y^T + alpha*y*x^T + A`, where `alpha` is a scalar, `x` and `y` are one-dimensional ndarrays, and `A` is an `N` by `N` symmetric matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray corresponding to `x`. + * - a one-dimensional input ndarray corresponding to `y`. + * - a two-dimensional input/output ndarray corresponding to `A`. + * - a zero-dimensional ndarray specifying whether the upper or lower triangular part of the symmetric matrix `A` should be referenced. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Matrix = require( '@stdlib/ndarray/matrix/float64' ); + * var Float64Vector = require( '@stdlib/ndarray/vector/float64' ); + * var resolveEnum = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Float64Matrix( [ [ 1.0, 2.0, 3.0 ], [ 2.0, 1.0, 2.0 ], [ 3.0, 2.0, 1.0 ] ] ); + * var x = new Float64Vector( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float64Vector( [ 2.0, 1.0, 3.0 ] ); + * + * var uplo = scalar2ndarray( resolveEnum( 'upper' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 2.0, { + * 'dtype': 'float64' + * }); + * + * var z = ns.dsyr2( [ x, y, A, uplo, alpha ] ); + * // returns [ [ 9.0, 12.0, 21.0 ], [ 2.0, 9.0, 20.0 ], [ 3.0, 2.0, 37.0 ] ] + * + * var bool = ( z === A ); + * // returns true + */ + dsyr2: typeof dsyr2; + /** * Computes the sum of absolute values for all elements in a one-dimensional double-precision complex floating-point ndarray. * @@ -752,6 +888,54 @@ interface Namespace { */ gdot: typeof gdot; + /** + * Performs the matrix-matrix operation `C = alpha*op(A)*op(B) + beta*C`, where `op(X)` is either `op(X) = X` or `op(X) = X^T`, `alpha` and `beta` are scalars, `A`, `B`, and `C` are matrices, with `op(A)` an `M` by `K` matrix, `op(B)` a `K` by `N` matrix, and `C` an `M` by `N` matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional input ndarray corresponding to `B`. + * - a two-dimensional input/output ndarray corresponding to `C`. + * - a zero-dimensional ndarray specifying whether `A` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray specifying whether `B` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `beta`. + * + * @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 resolveEnum = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); + * + * var A = matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], 'generic' ); + * var B = matrix( [ [ 1.0, 1.0 ], [ 0.0, 1.0 ] ], 'generic' ); + * var C = matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ], 'generic' ); + * + * var transA = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var transB = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * var beta = scalar2ndarray( 1.0, { + * 'dtype': 'generic' + * }); + * + * var z = ns.ggemm( [ A, B, C, transA, transB, alpha, beta ] ); + * // returns [ [ 2.0, 5.0 ], [ 6.0, 11.0 ] ] + * + * var bool = ( z === C ); + * // returns true + */ + ggemm: typeof ggemm; + /** * Performs one of the matrix-vector operations `y = alpha*A*x + beta*y` or `y = alpha*A^T*x + beta*y`, where `alpha` and `beta` are scalars, `x` and `y` are one-dimensional ndarrays, and `A` is an `M` by `N` matrix. * @@ -914,6 +1098,45 @@ interface Namespace { */ gswap: typeof gswap; + /** + * Performs the symmetric rank 1 operation `A = alpha*x*x^T + A`, where `alpha` is a scalar, `x` is a one-dimensional ndarray, and `A` is an `N` by `N` symmetric matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray corresponding to `x`. + * - a two-dimensional input ndarray corresponding to `A`. + * - a zero-dimensional ndarray specifying whether the upper or lower triangular part of the symmetric matrix `A` should be referenced. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var matrix = require( '@stdlib/ndarray/matrix/ctor' ); + * var vector = require( '@stdlib/ndarray/vector/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var resolveEnum = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' ); + * + * var x = vector( [ 1.0, 2.0, 3.0 ], 'generic' ); + * var A = matrix( [ [ 1.0, 2.0, 3.0 ], [ 2.0, 1.0, 2.0 ], [ 3.0, 2.0, 1.0 ] ], 'generic' ); + * + * var uplo = scalar2ndarray( resolveEnum( 'upper' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 2.0, { + * 'dtype': 'generic' + * }); + * + * var y = ns.gsyr( [ x, A, uplo, alpha ] ); + * // returns [ [ 3.0, 6.0, 9.0 ], [ 2.0, 9.0, 14.0 ], [ 3.0, 2.0, 19.0 ] ] + * + * var bool = ( y === A ); + * // returns true + */ + gsyr: typeof gsyr; + /** * Finds the index of the first element having the maximum absolute value for all elements in a one-dimensional double-precision floating-point ndarray. * @@ -1160,6 +1383,54 @@ interface Namespace { */ sdsdot: typeof sdsdot; + /** + * Performs the matrix-matrix operation `C = alpha*op(A)*op(B) + beta*C`, where `op(X)` is either `op(X) = X` or `op(X) = X^T`, `alpha` and `beta` are scalars, `A`, `B`, and `C` are matrices, with `op(A)` an `M` by `K` matrix, `op(B)` a `K` by `N` matrix, and `C` an `M` by `N` matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a two-dimensional input ndarray corresponding to `A`. + * - a two-dimensional input ndarray corresponding to `B`. + * - a two-dimensional input/output ndarray corresponding to `C`. + * - a zero-dimensional ndarray specifying whether `A` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray specifying whether `B` should be transposed, conjugate-transposed, or not transposed. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `beta`. + * + * @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 resolveEnum = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); + * + * var A = new Float32Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * var B = new Float32Matrix( [ [ 1.0, 1.0 ], [ 0.0, 1.0 ] ] ); + * var C = new Float32Matrix( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] ); + * + * var transA = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var transB = scalar2ndarray( resolveEnum( 'no-transpose' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 1.0, { + * 'dtype': 'float32' + * }); + * var beta = scalar2ndarray( 1.0, { + * 'dtype': 'float32' + * }); + * + * var z = ns.sgemm( [ A, B, C, transA, transB, alpha, beta ] ); + * // returns [ [ 2.0, 5.0 ], [ 6.0, 11.0 ] ] + * + * var bool = ( z === C ); + * // returns true + */ + sgemm: typeof sgemm; + /** * Performs one of the matrix-vector operations `y = alpha*A*x + beta*y` or `y = alpha*A^T*x + beta*y`, where `alpha` and `beta` are scalars, `x` and `y` are one-dimensional ndarrays, and `A` is an `M` by `N` matrix. * @@ -1360,6 +1631,86 @@ interface Namespace { */ sswap: typeof sswap; + /** + * Performs the symmetric rank 1 operation `A = alpha*x*x^T + A`, where `alpha` is a scalar, `x` is a one-dimensional ndarray, and `A` is an `N` by `N` symmetric matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray corresponding to `x`. + * - a two-dimensional input/output ndarray corresponding to `A`. + * - a zero-dimensional ndarray specifying whether the upper or lower triangular part of the symmetric matrix `A` should be referenced. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float32Matrix = require( '@stdlib/ndarray/matrix/float32' ); + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var resolveEnum = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' ); + * + * var x = new Float32Vector( [ 1.0, 2.0, 3.0 ] ); + * var A = new Float32Matrix( [ [ 1.0, 2.0, 3.0 ], [ 2.0, 1.0, 2.0 ], [ 3.0, 2.0, 1.0 ] ] ); + * + * var uplo = scalar2ndarray( resolveEnum( 'upper' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 1.0, { + * 'dtype': 'float32' + * }); + * + * var y = ns.ssyr( [ x, A, uplo, alpha ] ); + * // returns [ [ 2.0, 4.0, 6.0 ], [ 2.0, 5.0, 8.0 ], [ 3.0, 2.0, 10.0 ] ] + * + * var bool = ( y === A ); + * // returns true + */ + ssyr: typeof ssyr; + + /** + * Performs the symmetric rank 2 operation `A = alpha*x*y^T + alpha*y*x^T + A`, where `alpha` is a scalar, `x` and `y` are one-dimensional ndarrays, and `A` is an `N` by `N` symmetric matrix. + * + * ## Notes + * + * - The function expects the following ndarrays: + * + * - a one-dimensional input ndarray corresponding to `x`. + * - a one-dimensional input ndarray corresponding to `y`. + * - a two-dimensional input/output ndarray corresponding to `A`. + * - a zero-dimensional ndarray specifying whether the upper or lower triangular part of the symmetric matrix `A` should be referenced. + * - a zero-dimensional ndarray containing a scalar constant corresponding to `alpha`. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float32Matrix = require( '@stdlib/ndarray/matrix/float32' ); + * var Float32Vector = require( '@stdlib/ndarray/vector/float32' ); + * var resolveEnum = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * + * var A = new Float32Matrix( [ [ 1.0, 2.0, 3.0 ], [ 2.0, 1.0, 2.0 ], [ 3.0, 2.0, 1.0 ] ] ); + * var x = new Float32Vector( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float32Vector( [ 2.0, 1.0, 3.0 ] ); + * + * var uplo = scalar2ndarray( resolveEnum( 'upper' ), { + * 'dtype': 'int32' + * }); + * var alpha = scalar2ndarray( 2.0, { + * 'dtype': 'float32' + * }); + * + * var z = ns.ssyr2( [ x, y, A, uplo, alpha ] ); + * // returns [ [ 9.0, 12.0, 21.0 ], [ 2.0, 9.0, 20.0 ], [ 3.0, 2.0, 37.0 ] ] + * + * var bool = ( z === A ); + * // returns true + */ + ssyr2: typeof ssyr2; + /** * Multiplies a one-dimensional double-precision complex floating-point ndarray `x` by a constant `alpha` and adds the result to a one-dimensional double-precision complex floating-point ndarray `y`. *