From 0f037c71fff282dab778b8f23f7bdc67352557fd Mon Sep 17 00:00:00 2001 From: Planeshifter <1913638+Planeshifter@users.noreply.github.com> Date: Sat, 22 Feb 2025 02:26:46 +0000 Subject: [PATCH] feat: update namespace TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../@stdlib/assert/docs/types/index.d.ts | 2 +- .../@stdlib/blas/base/docs/types/index.d.ts | 314 ++++++++ .../blas/base/wasm/docs/types/index.d.ts | 750 +++++++++++++++++- .../blas/ext/base/docs/types/index.d.ts | 6 + .../blas/ext/base/wasm/docs/types/index.d.ts | 26 +- .../@stdlib/dstructs/docs/types/index.d.ts | 70 +- .../@stdlib/stats/base/docs/types/index.d.ts | 118 +-- 7 files changed, 1221 insertions(+), 65 deletions(-) diff --git a/lib/node_modules/@stdlib/assert/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/docs/types/index.d.ts index f33d9927759e..d78919294f58 100644 --- a/lib/node_modules/@stdlib/assert/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/assert/docs/types/index.d.ts @@ -3863,7 +3863,7 @@ interface Namespace { * @returns boolean indicating if a value is named typed tuple-like * * @example - * var namedtypedtuple = require( '@stdlib/utils/named-typed-tuple' ); + * var namedtypedtuple = require( '@stdlib/dstructs/named-typed-tuple' ); * * var Point = namedtypedtuple( [ 'x', 'y' ] ); * diff --git a/lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts index df9be155398a..f77dbcef7c74 100644 --- a/lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts @@ -31,6 +31,8 @@ import daxpy = require( '@stdlib/blas/base/daxpy' ); import dcabs1 = require( '@stdlib/blas/base/dcabs1' ); import dcopy = require( '@stdlib/blas/base/dcopy' ); import ddot = require( '@stdlib/blas/base/ddot' ); +import dgemm = require( '@stdlib/blas/base/dgemm' ); +import dgemv = require( '@stdlib/blas/base/dgemv' ); import diagonalTypeEnum2Str = require( '@stdlib/blas/base/diagonal-type-enum2str' ); import diagonalTypeResolveEnum = require( '@stdlib/blas/base/diagonal-type-resolve-enum' ); import diagonalTypeResolveStr = require( '@stdlib/blas/base/diagonal-type-resolve-str' ); @@ -43,11 +45,13 @@ import drotm = require( '@stdlib/blas/base/drotm' ); import dscal = require( '@stdlib/blas/base/dscal' ); import dsdot = require( '@stdlib/blas/base/dsdot' ); import dspmv = require( '@stdlib/blas/base/dspmv' ); +import dspr = require( '@stdlib/blas/base/dspr' ); import dswap = require( '@stdlib/blas/base/dswap' ); import dsymv = require( '@stdlib/blas/base/dsymv' ); import dsyr = require( '@stdlib/blas/base/dsyr' ); import dsyr2 = require( '@stdlib/blas/base/dsyr2' ); import dtrmv = require( '@stdlib/blas/base/dtrmv' ); +import dtrsv = require( '@stdlib/blas/base/dtrsv' ); import dznrm2 = require( '@stdlib/blas/base/dznrm2' ); import gasum = require( '@stdlib/blas/base/gasum' ); import gaxpy = require( '@stdlib/blas/base/gaxpy' ); @@ -81,6 +85,7 @@ import scnrm2 = require( '@stdlib/blas/base/scnrm2' ); import scopy = require( '@stdlib/blas/base/scopy' ); import sdot = require( '@stdlib/blas/base/sdot' ); import sdsdot = require( '@stdlib/blas/base/sdsdot' ); +import sgemm = require( '@stdlib/blas/base/sgemm' ); import sgemv = require( '@stdlib/blas/base/sgemv' ); import snrm2 = require( '@stdlib/blas/base/snrm2' ); import srot = require( '@stdlib/blas/base/srot' ); @@ -88,19 +93,23 @@ import srotg = require( '@stdlib/blas/base/srotg' ); import srotm = require( '@stdlib/blas/base/srotm' ); import sscal = require( '@stdlib/blas/base/sscal' ); import sspmv = require( '@stdlib/blas/base/sspmv' ); +import sspr = require( '@stdlib/blas/base/sspr' ); import sswap = require( '@stdlib/blas/base/sswap' ); import ssymv = require( '@stdlib/blas/base/ssymv' ); import ssyr = require( '@stdlib/blas/base/ssyr' ); import ssyr2 = require( '@stdlib/blas/base/ssyr2' ); import strmv = require( '@stdlib/blas/base/strmv' ); +import strsv = require( '@stdlib/blas/base/strsv' ); import transposeOperationEnum2Str = require( '@stdlib/blas/base/transpose-operation-enum2str' ); import transposeOperationResolveEnum = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); import transposeOperationResolveStr = require( '@stdlib/blas/base/transpose-operation-resolve-str' ); import transposeOperationStr2Enum = require( '@stdlib/blas/base/transpose-operation-str2enum' ); import transposeOperations = require( '@stdlib/blas/base/transpose-operations' ); +import wasm = require( '@stdlib/blas/base/wasm' ); import zaxpy = require( '@stdlib/blas/base/zaxpy' ); import zcopy = require( '@stdlib/blas/base/zcopy' ); import zdrot = require( '@stdlib/blas/base/zdrot' ); +import zdscal = require( '@stdlib/blas/base/zdscal' ); import zscal = require( '@stdlib/blas/base/zscal' ); import zswap = require( '@stdlib/blas/base/zswap' ); @@ -406,6 +415,86 @@ interface Namespace { */ ddot: typeof ddot; + /** + * Performs the matrix-matrix operation `C = α*op(A)*op(B) + β*C` where `op(X)` is either `op(X) = X` or `op(X) = X^T`, `α` and `β` 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. + * + * @param order - storage layout + * @param transA - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param transB - specifies whether `B` should be transposed, conjugate-transposed, or not transposed + * @param M - number of rows in the matrix `op(A)` and in the matrix `C` + * @param N - number of columns in the matrix `op(B)` and in the matrix `C` + * @param K - number of columns in the matrix `op(A)` and number of rows in the matrix `op(B)` + * @param alpha - scalar constant + * @param A - first matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param B - second matrix + * @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`) + * @param beta - scalar constant + * @param C - third matrix + * @param LDC - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`) + * @returns `C` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * var B = new Float64Array( [ 1.0, 0.0, 1.0, 1.0 ] ); + * var C = new Float64Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * + * ns.dgemm( 'column-major', 'no-transpose', 'no-transpose', 2, 2, 2, 1.0, A, 2, B, 2, 1.0, C, 2 ); + * // C => [ 2.0, 6.0, 5.0, 11.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * var B = new Float64Array( [ 1.0, 0.0, 1.0, 1.0 ] ); + * var C = new Float64Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * + * ns.dgemm.ndarray( 'no-transpose', 'no-transpose', 2, 2, 2, 1.0, A, 1, 2, 0, B, 1, 2, 0, 1.0, C, 1, 2, 0 ); + * // C => [ 2.0, 6.0, 5.0, 11.0 ] + */ + dgemm: typeof dgemm; + + /** + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + * + * @param order - storage layout + * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param M - number of rows in the matrix `A` + * @param N - number of columns in the matrix `A` + * @param alpha - scalar constant + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - first input vector + * @param strideX - `x` stride length + * @param beta - scalar constant + * @param y - second input vector + * @param strideY - `y` stride length + * @returns `y` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] ); + * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * var y = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.dgemv( 'row-major', 'no-transpose', 3, 3, 1.0, A, 3, x1, -1, 1.0, y1, -1 ); + * // y => [ 25.0, 16.0, 7.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] ); + * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * var y = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.dgemv.ndarray( 'no-transpose', 3, 3, 1.0, A, 3, 1, 0, x1, -1, 2, 1.0, y1, -1, 2 ); + * // y => [ 25.0, 16.0, 7.0 ] + */ + dgemv: typeof dgemv; + /** * Returns the BLAS diagonal type string associated with a BLAS diagonal type enumeration constant. * @@ -692,6 +781,38 @@ interface Namespace { */ dspmv: typeof dspmv; + /** + * Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form. + * + * @param order - storage layout + * @param uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is being supplied + * @param N - number of elements along each dimension of `A` + * @param alpha - scalar constant + * @param x - input vector + * @param strideX - `x` stride length + * @param AP - packed form of a symmetric matrix `A` + * @returns `AP` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var AP = new Float64Array( [ 1.0, 1.0, 2.0, 1.0, 2.0, 3.0 ] ); + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * + * ns.dspr( 'row-major', 'lower', 3, 1.0, x, 1, AP ); + * // AP => [ 2.0, 3.0, 6.0, 4.0, 8.0, 12.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var AP = new Float64Array( [ 1.0, 1.0, 2.0, 1.0, 2.0, 3.0 ] ); + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * + * ns.dspr.ndarray( 'row-major', 'lower', 3, 1.0, x, 1, 0, AP, 1, 0 ); + * // AP => [ 2.0, 3.0, 6.0, 4.0, 8.0, 12.0 ] + */ + dspr: typeof dspr; + /** * Interchanges two double-precision floating-point vectors. * @@ -866,6 +987,40 @@ interface Namespace { */ dtrmv: typeof dtrmv; + /** + * Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix. + * + * @param order - storage layout + * @param uplo - specifies whether `A` is an upper or lower triangular matrix + * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param diag - specifies whether `A` has a unit diagonal + * @param N - number of elements along each dimension in the matrix `A` + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - input vector + * @param strideX - `x` stride length + * @returns `x` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] ); + * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.dtrsv( 'row-major', 'lower', 'no-transpose', 'non-unit', 3, A, 3, x, 1 ); + * // x => [ 1.0, ~-0.33, ~-0.22 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] ); + * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.dtrsv.ndarray( 'lower', 'no-transpose', 'non-unit', 3, A, 3, 1, 0, x, 1, 0 ); + * // x => [ 1.0, ~-0.33, ~-0.22 ] + */ + dtrsv: typeof dtrsv; + /** * Computes the L2-norm of a complex double-precision floating-point vector. * @@ -1554,6 +1709,47 @@ interface Namespace { */ sdsdot: typeof sdsdot; + /** + * Performs the matrix-matrix operation `C = α*op(A)*op(B) + β*C` where `op(X)` is either `op(X) = X` or `op(X) = X^T`, `α` and `β` 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. + * + * @param order - storage layout + * @param transA - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param transB - specifies whether `B` should be transposed, conjugate-transposed, or not transposed + * @param M - number of rows in the matrix `op(A)` and in the matrix `C` + * @param N - number of columns in the matrix `op(B)` and in the matrix `C` + * @param K - number of columns in the matrix `op(A)` and number of rows in the matrix `op(B)` + * @param alpha - scalar constant + * @param A - first matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param B - second matrix + * @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`) + * @param beta - scalar constant + * @param C - third matrix + * @param LDC - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`) + * @returns `C` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * var B = new Float32Array( [ 1.0, 0.0, 1.0, 1.0 ] ); + * var C = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * + * ns.sgemm( 'column-major', 'no-transpose', 'no-transpose', 2, 2, 2, 1.0, A, 2, B, 2, 1.0, C, 2 ); + * // C => [ 2.0, 6.0, 5.0, 11.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * var B = new Float32Array( [ 1.0, 0.0, 1.0, 1.0 ] ); + * var C = new Float32Array( [ 1.0, 3.0, 2.0, 4.0 ] ); + * + * ns.sgemm.ndarray( 'no-transpose', 'no-transpose', 2, 2, 2, 1.0, A, 1, 2, 0, B, 1, 2, 0, 1.0, C, 1, 2, 0 ); + * // C => [ 2.0, 6.0, 5.0, 11.0 ] + */ + sgemm: typeof sgemm; + /** * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * @@ -1775,6 +1971,38 @@ interface Namespace { */ sspmv: typeof sspmv; + /** + * Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form. + * + * @param order - storage layout + * @param uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied + * @param N - number of elements along each dimension of `A` + * @param alpha - scalar constant + * @param x - first input array + * @param strideX - `x` stride length + * @param AP - packed form of a symmetric matrix `A` + * @returns `AP` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var AP = new Float32Array( [ 1.0, 1.0, 2.0, 1.0, 2.0, 3.0 ] ); + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * + * ns.sspr( 'row-major', 'lower', 3, 1.0, x, 1, AP ); + * // AP => [ 2.0, 3.0, 6.0, 4.0, 8.0, 12.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var AP = new Float32Array( [ 1.0, 1.0, 2.0, 1.0, 2.0, 3.0 ] ); + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * + * ns.sspr.ndarray( 'row-major', 'lower', 3, 1.0, x, 1, 0, AP, 1, 0 ); + * // AP => [ 2.0, 3.0, 6.0, 4.0, 8.0, 12.0 ] + */ + sspr: typeof sspr; + /** * Interchanges two single-precision floating-point vectors. * @@ -1949,6 +2177,40 @@ interface Namespace { */ strmv: typeof strmv; + /** + * Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix. + * + * @param order - storage layout + * @param uplo - specifies whether `A` is an upper or lower triangular matrix + * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param diag - specifies whether `A` has a unit diagonal + * @param N - number of elements along each dimension in the matrix `A` + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - input vector + * @param strideX - `x` stride length + * @returns `x` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] ); + * var x = new Float32Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.strsv( 'row-major', 'lower', 'no-transpose', 'non-unit', 3, A, 3, x, 1 ); + * // x => [ 1.0, ~-0.33, ~-0.22 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] ); + * var x = new Float32Array( [ 1.0, 1.0, 1.0 ] ); + * + * ns.strsv.ndarray( 'lower', 'no-transpose', 'non-unit', 3, A, 3, 1, 0, x, 1, 0 ); + * // x => [ 1.0, ~-0.33, ~-0.22 ] + */ + strsv: typeof strsv; + /** * Returns the BLAS transpose operation string associated with a BLAS transpose operation enumeration constant. * @@ -2023,6 +2285,11 @@ interface Namespace { */ transposeOperations: typeof transposeOperations; + /** + * Basic linear algebra subprograms (BLAS) compiled to WebAssembly. + */ + wasm: typeof wasm; + /** * Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector. * @@ -2122,6 +2389,53 @@ interface Namespace { */ zdrot: typeof zdrot; + /** + * Scales a double-precision complex floating-point vector by a double-precision floating-point constant. + * + * @param N - number of indexed elements + * @param da - scalar constant + * @param zx - input array + * @param strideZX - `zx` stride length + * @returns input array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * ns.zdscal( 3, 2.0, zx, 1 ); + * + * var z = zx.get( 1 ); + * // returns + * + * var re = real( z ); + * // returns 6.0 + * + * var im = imag( z ); + * // returns 8.0 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * ns.zdscal.ndarray( 2, 2.0, zx, 1, 1 ); + * + * var z = zx.get( 1 ); + * // returns + * + * var re = real( z ); + * // returns 10.0 + * + * var im = imag( z ); + * // returns 12.0 + */ + zdscal: typeof zdscal; + /** * Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant. * diff --git a/lib/node_modules/@stdlib/blas/base/wasm/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/wasm/docs/types/index.d.ts index dcf58369395b..dc7e7ff1c5ab 100644 --- a/lib/node_modules/@stdlib/blas/base/wasm/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/wasm/docs/types/index.d.ts @@ -20,12 +20,163 @@ /* eslint-disable max-lines */ +import ccopy = require( '@stdlib/blas/base/ccopy' ); +import cscal = require( '@stdlib/blas/base/cscal' ); +import csrot = require( '@stdlib/blas/base/csrot' ); +import cswap = require( '@stdlib/blas/base/cswap' ); import dasum = require( '@stdlib/blas/base/dasum' ); +import daxpy = require( '@stdlib/blas/base/daxpy' ); +import dcopy = require( '@stdlib/blas/base/dcopy' ); +import ddot = require( '@stdlib/blas/base/ddot' ); +import dnrm2 = require( '@stdlib/blas/base/dnrm2' ); +import drot = require( '@stdlib/blas/base/drot' ); +import drotm = require( '@stdlib/blas/base/drotm' ); +import dscal = require( '@stdlib/blas/base/dscal' ); +import dswap = require( '@stdlib/blas/base/dswap' ); +import idamax = require( '@stdlib/blas/base/idamax' ); +import isamax = require( '@stdlib/blas/base/isamax' ); +import sasum = require( '@stdlib/blas/base/sasum' ); +import saxpy = require( '@stdlib/blas/base/saxpy' ); +import scopy = require( '@stdlib/blas/base/scopy' ); +import sdot = require( '@stdlib/blas/base/sdot' ); +import snrm2 = require( '@stdlib/blas/base/snrm2' ); +import srot = require( '@stdlib/blas/base/srot' ); +import sscal = require( '@stdlib/blas/base/sscal' ); +import zcopy = require( '@stdlib/blas/base/zcopy' ); +import zdrot = require( '@stdlib/blas/base/zdrot' ); +import zswap = require( '@stdlib/blas/base/zswap' ); /** -* Interface describing the namespace. +* Interface describing the `wasm` namespace. */ interface Namespace { + /** + * Copies values from one complex single-precision floating-point vector to another complex single-precision floating-point vector. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.ccopy( x.length, x, 1, y, 1 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.ccopy.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + */ + ccopy: typeof ccopy; + + /** + * Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant. + * + * @param N - number of indexed elements + * @param ca - scalar constant + * @param cx - input array + * @param strideX - `cx` stride length + * @returns input array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var ca = new Complex64( 2.0, 2.0 ); + * + * ns.cscal( 3, ca, cx, 1 ); + * // cx => [ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var ca = new Complex64( 2.0, 2.0 ); + * + * ns.cscal.ndarray( 3, ca, cx, 1, 0 ); + * // cx => [ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ] + */ + cscal: typeof cscal; + + /** + * Applies a plane rotation. + * + * @param N - number of indexed elements + * @param cx - first input array + * @param strideX - `cx` stride length + * @param cy - second input array + * @param strideY - `cy` stride length + * @param c - cosine of the angle of rotation + * @param s - sine of the angle of rotation + * @returns `cy` + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var cy = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.csrot( 2, cx, 2, cy, 1, 0.8, 0.6 ); + * // cx => [ ~0.8, ~1.6, 3.0, 4.0, 4.0, ~4.8, 7.0, 8.0 ] + * // cy => [ ~-0.6, ~-1.2, -3.0, ~-3.6, 0.0, 0.0, 0.0, 0.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var cy = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.csrot.ndarray( 2, cx, 2, 0, cy, 1, 0, 0.8, 0.6 ); + * // cx => [ ~0.8, ~1.6, 3.0, 4.0, 4.0, ~4.8, 7.0, 8.0 ] + * // cy => [ ~-0.6, ~-1.2, -3.0, ~-3.6, 0.0, 0.0, 0.0, 0.0 ] + */ + csrot: typeof csrot; + + /** + * Interchanges two complex single-precision floating-point vectors. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns `y` + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.cswap( x.length, x, 1, y, 1 ); + * // x => [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.cswap.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // x => [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + */ + cswap: typeof cswap; + /** * Computes the sum of the absolute values. * @@ -51,6 +202,603 @@ interface Namespace { * // returns 21.0 */ dasum: typeof dasum; + + /** + * Multiplies a vector `x` by a constant `alpha` and adds the result to `y`. + * + * @param N - number of indexed elements + * @param alpha - constant + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * ns.daxpy( x.length, 5.0, x, 1, y, 1 ); + * // y => [ 6.0, 11.0, 16.0, 21.0, 26.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * ns.daxpy.ndarray( x.length, 5.0, x, 1, 0, y, 1, 0 ); + * // y => [ 6.0, 11.0, 16.0, 21.0, 26.0 ] + */ + daxpy: typeof daxpy; + + /** + * Copies values from `x` into `y`. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.dcopy( x.length, x, 1, y, 1 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.dcopy.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + */ + dcopy: typeof dcopy; + + /** + * Computes the dot product of `x` and `y`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns dot product + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] ); + * var y = new Float64Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.ddot( x.length, x, 1, y, 1 ); + * // returns -5.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] ); + * var y = new Float64Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.ddot.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns -5.0 + */ + ddot: typeof ddot; + + /** + * Computes the L2-norm of a double-precision floating-point vector. + * + * @param N - number of indexed elements + * @param x - input array + * @param stride - stride length + * @returns L2-norm + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var z = ns.dnrm2( x.length, x, 1 ); + * // returns 3.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var z = ns.dnrm2.ndarray( x.length, x, 1, 0 ); + * // returns 3.0 + */ + dnrm2: typeof dnrm2; + + /** + * Applies a plane rotation. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param c - cosine of the angle of rotation + * @param s - sine of the angle of rotation + * @returns `y` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.drot( x.length, x, 1, y, 1, 0.8, 0.6 ); + * // x => [ ~4.4, ~5.8, 7.2, 8.6, 10.0 ] + * // y => [ ~4.2, 4.4, ~4.6, ~4.8, 5.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + * + * ns.drot.ndarray( 3, x, 2, 1, y, 2, 1, 0.8, 0.6 ); + * // x => [ 1.0, 6.4, 3.0, 9.2, 5.0, 12.0 ] + * // y => [ 7.0, 5.2, 9.0, 5.6, 11.0, ~6.0 ] + */ + drot: typeof drot; + + /** + * Applies a modified Givens plane rotation. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param param - parameters for the modified Givens transformation + * @returns `y` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * var param = new Float64Array( [ 0.0, 0.0, 2.0, -3.0, 0.0 ] ); + * + * ns.drotm( 2, x, 2, y, 1, param ); + * // x => [ ~-17.0, 2.0, ~-18.0, 4.0, 5.0 ] + * // y => [ ~8.0, ~13.0, 8.0, 9.0, 10.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * var param = new Float64Array( [ 0.0, 0.0, 2.0, -3.0, 0.0 ] ); + * + * ns.drotm.ndarray( 2, x, 1, 0, y, 2, 1, param ); + * // x => [ ~-20.0, ~-25.0, 3.0, 4.0, 5.0 ] + * // y => [ 6.0, ~9.0, 8.0, ~13.0, 10.0 ] + */ + drotm: typeof drotm; + + /** + * Multiplies a double-precision floating-point vector `x` by a constant `alpha`. + * + * @param N - number of indexed elements + * @param alpha - constant + * @param x - input array + * @param stride - index increment + * @returns input array + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * ns.dscal( x.length, 5.0, x, 1 ); + * // x => [ -10.0, 5.0, 15.0, -25.0, 20.0, 0.0, -5.0, -15.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * ns.dscal.ndarray( x.length, 5.0, x, 1, 0 ); + * // x => [ -10.0, 5.0, 15.0, -25.0, 20.0, 0.0, -5.0, -15.0 ] + */ + dscal: typeof dscal; + + /** + * Interchanges two double-precision floating-point vectors. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns `y` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.dswap( x.length, x, 1, y, 1 ); + * // x => [ 6.0, 7.0, 8.0, 9.0, 10.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.dswap.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // x => [ 6.0, 7.0, 8.0, 9.0, 10.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + */ + dswap: typeof dswap; + + /** + * Finds the index of the first element having the maximum absolute value. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @returns index value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * var idx = ns.idamax( 4, x, 2 ); + * // returns 2 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * var idx = ns.idamax.ndarray( x.length, x, 1, 0 ); + * // returns 3 + */ + idamax: typeof idamax; + + /** + * Finds the index of the first element having the maximum absolute value. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @returns index value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * var idx = ns.isamax( 4, x, 2 ); + * // returns 2 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * var idx = ns.isamax.ndarray( x.length, x, 1, 0 ); + * // returns 3 + */ + isamax: typeof isamax; + + /** + * Computes the sum of the absolute values. + * + * @param N - number of indexed elements + * @param x - input array + * @param stride - stride length + * @returns sum of absolute values + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.sasum( x.length, x, 1 ); + * // returns 15.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.sasum.ndarray( x.length, x, 1, 0 ); + * // returns 21.0 + */ + sasum: typeof sasum; + + /** + * Multiplies a vector `x` by a constant `alpha` and adds the result to `y`. + * + * @param N - number of indexed elements + * @param alpha - constant + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * ns.saxpy( x.length, 5.0, x, 1, y, 1 ); + * // y => [ 6.0, 11.0, 16.0, 21.0, 26.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * ns.saxpy.ndarray( x.length, 5.0, x, 1, 0, y, 1, 0 ); + * // y => [ 6.0, 11.0, 16.0, 21.0, 26.0 ] + */ + saxpy: typeof saxpy; + + /** + * Copies values from `x` into `y`. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.scopy( x.length, x, 1, y, 1 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.scopy.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0 ] + */ + scopy: typeof scopy; + + /** + * Computes the dot product of `x` and `y`. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns dot product + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] ); + * var y = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.sdot( x.length, x, 1, y, 1 ); + * // returns -5.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] ); + * var y = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] ); + * + * var z = ns.sdot.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // returns -5.0 + */ + sdot: typeof sdot; + + /** + * Computes the L2-norm of a single-precision floating-point vector. + * + * @param N - number of indexed elements + * @param x - input array + * @param stride - stride length + * @returns L2-norm + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var z = ns.snrm2( x.length, x, 1 ); + * // returns 3.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var z = ns.snrm2.ndarray( x.length, x, 1, 0 ); + * // returns 3.0 + */ + snrm2: typeof snrm2; + + /** + * Applies a plane rotation. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @param c - cosine of the angle of rotation + * @param s - sine of the angle of rotation + * @returns `y` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + * + * ns.srot( 3, x, 2, y, 2, 0.8, 0.6 ); + * // x => [ 5.0, 2.0, ~7.8, 4.0, ~10.6, 6.0 ] + * // y => [ 5.0, 8.0, ~5.4, 10.0, ~5.8, 12.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ); + * var y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * + * ns.srot.ndarray( 4, x, 1, 1, y, 1, 1, 0.8, 0.6 ); + * // x => [ 1.0, ~5.8, ~7.2, ~8.6, 10.0 ] + * // y => [ 6.0, ~4.4, ~4.6, ~4.8, 5.0 ] + */ + srot: typeof srot; + + /** + * Multiplies a single-precision floating-point vector `x` by a constant `alpha`. + * + * @param N - number of indexed elements + * @param alpha - constant + * @param x - input array + * @param stride - index increment + * @returns input array + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * ns.sscal( x.length, 5.0, x, 1 ); + * // x => [ -10.0, 5.0, 15.0, -25.0, 20.0, 0.0, -5.0, -15.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] ); + * + * ns.sscal.ndarray( x.length, 5.0, x, 1, 0 ); + * // x => [ -10.0, 5.0, 15.0, -25.0, 20.0, 0.0, -5.0, -15.0 ] + */ + sscal: typeof sscal; + + /** + * Copies values from one complex double-precision floating-point vector to another complex double-precision floating-point vector. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param y - output array + * @param strideY - `y` stride length + * @returns output array + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zcopy( x.length, x, 1, y, 1 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zcopy.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + */ + zcopy: typeof zcopy; + + /** + * Applies a plane rotation. + * + * @param N - number of indexed elements + * @param zx - first input array + * @param strideX - `zx` stride length + * @param zy - second input array + * @param strideY - `zy` stride length + * @param c - cosine of the angle of rotation + * @param s - sine of the angle of rotation + * @returns `zy` + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zdrot( 2, zx, 2, zy, 1, 0.8, 0.6 ); + * // zx => [ ~0.8, ~1.6, 3.0, 4.0, 4.0, ~4.8, 7.0, 8.0 ] + * // zy => [ ~-0.6, ~-1.2, -3.0, ~-3.6, 0.0, 0.0, 0.0, 0.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zdrot.ndarray( 2, zx, 2, 0, zy, 1, 0, 0.8, 0.6 ); + * // zx => [ ~0.8, ~1.6, 3.0, 4.0, 4.0, ~4.8, 7.0, 8.0 ] + * // zy => [ ~-0.6, ~-1.2, -3.0, ~-3.6, 0.0, 0.0, 0.0, 0.0 ] + */ + zdrot: typeof zdrot; + + /** + * Interchanges two complex double-precision floating-point vectors. + * + * @param N - number of indexed elements + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns `y` + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zswap( x.length, x, 1, y, 1 ); + * // x => [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * + * ns.zswap.ndarray( x.length, x, 1, 0, y, 1, 0 ); + * // x => [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] + */ + zswap: typeof zswap; } /** 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 ac4693de310e..9192f66f00d9 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 @@ -134,6 +134,7 @@ import ssumkbn = require( '@stdlib/blas/ext/base/ssumkbn' ); import ssumkbn2 = require( '@stdlib/blas/ext/base/ssumkbn2' ); import ssumors = require( '@stdlib/blas/ext/base/ssumors' ); import ssumpw = require( '@stdlib/blas/ext/base/ssumpw' ); +import wasm = require( '@stdlib/blas/ext/base/wasm' ); /** * Interface describing the `base` namespace. @@ -3269,6 +3270,11 @@ interface Namespace { * // returns 1.0 */ ssumpw: typeof ssumpw; + + /** + * Extensions to basic linear algebra subprograms (BLAS) compiled to WebAssembly. + */ + wasm: typeof wasm; } /** diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/docs/types/index.d.ts index eaf126e5587b..192d310237e8 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/docs/types/index.d.ts @@ -23,11 +23,33 @@ import dapxsumkbn = require( '@stdlib/blas/ext/base/dapxsumkbn' ); /** -* Interface describing the namespace. +* Interface describing the `wasm` namespace. */ interface Namespace { /** - * TODO + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param x - input array + * @param strideX - stride length + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.dapxsumkbn( x.length, 5.0, x, 1 ); + * // returns 16.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 ); + * // returns 16.0 */ dapxsumkbn: typeof dapxsumkbn; } diff --git a/lib/node_modules/@stdlib/dstructs/docs/types/index.d.ts b/lib/node_modules/@stdlib/dstructs/docs/types/index.d.ts index 65661b69b52f..19f46d23529c 100644 --- a/lib/node_modules/@stdlib/dstructs/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/dstructs/docs/types/index.d.ts @@ -21,15 +21,81 @@ /* eslint-disable max-lines */ import CircularBuffer = require( '@stdlib/dstructs/circular-buffer' ); +import CompactAdjacencyMatrix = require( '@stdlib/dstructs/compact-adjacency-matrix' ); +import DoublyLinkedList = require( '@stdlib/dstructs/doubly-linked-list' ); +import FIFO = require( '@stdlib/dstructs/fifo' ); +import LinkedList = require( '@stdlib/dstructs/linked-list' ); +import namedtypedtuple = require( '@stdlib/dstructs/named-typed-tuple' ); +import Stack = require( '@stdlib/dstructs/stack' ); /** -* Interface describing the namespace. +* Interface describing the `dstructs` namespace. */ interface Namespace { /** - * TODO + * Circular buffer. */ CircularBuffer: typeof CircularBuffer; + + /** + * TODO + * + * @example + * // TODO + */ + CompactAdjacencyMatrix: typeof CompactAdjacencyMatrix; + + /** + * List node. + */ + DoublyLinkedList: typeof DoublyLinkedList; + + /** + * First-in-first-out (FIFO) queue. + */ + FIFO: typeof FIFO; + + /** + * List node. + */ + LinkedList: typeof LinkedList; + + /** + * Returns a named typed tuple factory. + * + * @param names - field (property) names + * @param options - options + * @param options.dtype - default data type (default: 'float64') + * @param options.name - tuple name (default: 'tuple') + * @throws must provide distinct field names + * @throws cannot provide a reserved field (property) name + * @throws must provide valid options + * @throws must provide a recognized data type + * @returns factory function + * + * @example + * var point = ns.namedtypedtuple( [ 'x', 'y' ] ); + * + * var p = point( [ 1.0, -1.0 ] ); + * + * var x = p[ 0 ]; + * // returns 1.0 + * + * x = p.x; + * // returns 1.0 + * + * var y = p[ 1 ]; + * // returns -1.0 + * + * y = p.y; + * // returns -1.0 + */ + namedtypedtuple: typeof namedtypedtuple; + + /** + * Stack + */ + Stack: typeof Stack; } /** diff --git a/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts index deebd312d929..73b597fe2538 100644 --- a/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/docs/types/index.d.ts @@ -35,8 +35,6 @@ import dmeanvarpn = require( '@stdlib/stats/base/dmeanvarpn' ); import dmskmax = require( '@stdlib/stats/base/dmskmax' ); import dmskmin = require( '@stdlib/stats/base/dmskmin' ); import dmskrange = require( '@stdlib/stats/base/dmskrange' ); -import dnanmax = require( '@stdlib/stats/strided/dnanmax' ); -import dnanmaxabs = require( '@stdlib/stats/strided/dnanmaxabs' ); import dnanmean = require( '@stdlib/stats/base/dnanmean' ); import dnanmeanors = require( '@stdlib/stats/base/dnanmeanors' ); import dnanmeanpn = require( '@stdlib/stats/base/dnanmeanpn' ); @@ -230,6 +228,8 @@ import dmidrange = require( '@stdlib/stats/strided/dmidrange' ); import dmin = require( '@stdlib/stats/strided/dmin' ); import dminabs = require( '@stdlib/stats/strided/dminabs' ); import dminsorted = require( '@stdlib/stats/strided/dminsorted' ); +import dnanmax = require( '@stdlib/stats/strided/dnanmax' ); +import dnanmaxabs = require( '@stdlib/stats/strided/dnanmaxabs' ); /** * Interface describing the `base` namespace. @@ -646,58 +646,6 @@ interface Namespace { */ dmskrange: typeof dmskrange; - /** - * Computes the maximum value of a double-precision floating-point strided array, ignoring `NaN` values. - * - * @param N - number of indexed elements - * @param x - input array - * @param strideX - stride length - * @returns maximum value - * - * @example - * var Float64Array = require( '@stdlib/array/float64' ); - * - * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); - * - * var v = ns.dnanmax( x.length, x, 1 ); - * // returns 2.0 - * - * @example - * var Float64Array = require( '@stdlib/array/float64' ); - * - * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); - * - * var v = ns.dnanmax.ndarray( x.length, x, 1, 0 ); - * // returns 2.0 - */ - dnanmax: typeof dnanmax; - - /** - * Computes the maximum absolute value of a double-precision floating-point strided array, ignoring `NaN` values. - * - * @param N - number of indexed elements - * @param x - input array - * @param strideX - stride length - * @returns maximum absolute value - * - * @example - * var Float64Array = require( '@stdlib/array/float64' ); - * - * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); - * - * var v = ns.dnanmaxabs( x.length, x, 1 ); - * // returns 2.0 - * - * @example - * var Float64Array = require( '@stdlib/array/float64' ); - * - * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); - * - * var v = ns.dnanmaxabs.ndarray( x.length, x, 1, 0 ); - * // returns 2.0 - */ - dnanmaxabs: typeof dnanmaxabs; - /** * Computes the arithmetic mean of a double-precision floating-point strided array, ignoring `NaN` values. * @@ -2302,7 +2250,7 @@ interface Namespace { * * @param N - number of indexed elements * @param x - sorted input array - * @param stride - stride length + * @param strideX - stride length * @returns maximum value * * @example @@ -2478,7 +2426,7 @@ interface Namespace { * * @param N - number of indexed elements * @param x - sorted input array - * @param stride - stride length + * @param strideX - stride length * @returns median value * * @example @@ -2587,7 +2535,7 @@ interface Namespace { * * @param N - number of indexed elements * @param x - sorted input array - * @param stride - stride length + * @param strideX - stride length * @returns minimum value * * @example @@ -2609,9 +2557,9 @@ interface Namespace { * * @param N - number of indexed elements * @param x - input array - * @param strideX - `x` stride length + * @param strideX - stride length for `x` * @param mask - mask array - * @param strideMask - `mask` stride length + * @param strideMask - stride length for `mask` * @returns maximum value * * @example @@ -5793,6 +5741,58 @@ interface Namespace { * // returns 1.0 */ dminsorted: typeof dminsorted; + + /** + * Computes the maximum value of a double-precision floating-point strided array, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns maximum value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmax( x.length, x, 1 ); + * // returns 2.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmax.ndarray( x.length, x, 1, 0 ); + * // returns 2.0 + */ + dnanmax: typeof dnanmax; + + /** + * Computes the maximum absolute value of a double-precision floating-point strided array, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns maximum absolute value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmaxabs( x.length, x, 1 ); + * // returns 2.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmaxabs.ndarray( x.length, x, 1, 0 ); + * // returns 2.0 + */ + dnanmaxabs: typeof dnanmaxabs; } /**