From 92f18722d245a8e98986f72fd6bd4c17431d3eb5 Mon Sep 17 00:00:00 2001 From: Planeshifter <1913638+Planeshifter@users.noreply.github.com> Date: Wed, 22 Jan 2025 02:28:44 +0000 Subject: [PATCH] feat: update namespace TypeScript declarations Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> --- .../@stdlib/blas/base/docs/types/index.d.ts | 28 +- .../@stdlib/lapack/base/docs/types/index.d.ts | 564 ++++++++++++++++++ .../@stdlib/stats/base/docs/types/index.d.ts | 31 - 3 files changed, 568 insertions(+), 55 deletions(-) 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 4c34a6918007..02e8119639a9 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 @@ -180,41 +180,21 @@ interface Namespace { * * @example * var Complex64Array = require( '@stdlib/array/complex64' ); - * var realf = require( '@stdlib/complex/float32/real' ); - * var imagf = require( '@stdlib/complex/float32/imag' ); * * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); - * var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.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 ); - * - * var z = y.get( 0 ); - * // returns - * - * var re = realf( z ); - * // returns 1.0 - * - * var im = imagf( z ); - * // returns 2.0 + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] * * @example * var Complex64Array = require( '@stdlib/array/complex64' ); - * var realf = require( '@stdlib/complex/float32/real' ); - * var imagf = require( '@stdlib/complex/float32/imag' ); * * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); - * var y = new Complex64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.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 ); - * - * var z = y.get( 0 ); - * // returns - * - * var re = realf( z ); - * // returns 1.0 - * - * var im = imagf( z ); - * // returns 2.0 + * // y => [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] */ ccopy: typeof ccopy; diff --git a/lib/node_modules/@stdlib/lapack/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/docs/types/index.d.ts index e9b598da6965..fe7cb2b445e0 100644 --- a/lib/node_modules/@stdlib/lapack/base/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/docs/types/index.d.ts @@ -20,17 +20,271 @@ /* eslint-disable max-lines */ +import clacgv = require( '@stdlib/lapack/base/clacgv' ); +import clacpy = require( '@stdlib/lapack/base/clacpy' ); +import claset = require( '@stdlib/lapack/base/claset' ); +import crot = require( '@stdlib/lapack/base/crot' ); +import dgetrans = require( '@stdlib/lapack/base/dge-trans' ); import dlacpy = require( '@stdlib/lapack/base/dlacpy' ); +import dlamch = require( '@stdlib/lapack/base/dlamch' ); import dlassq = require( '@stdlib/lapack/base/dlassq' ); import dlaswp = require( '@stdlib/lapack/base/dlaswp' ); import dpttrf = require( '@stdlib/lapack/base/dpttrf' ); +import sgetrans = require( '@stdlib/lapack/base/sge-trans' ); import slacpy = require( '@stdlib/lapack/base/slacpy' ); +import slaswp = require( '@stdlib/lapack/base/slaswp' ); import spttrf = require( '@stdlib/lapack/base/spttrf' ); +import zlacgv = require( '@stdlib/lapack/base/zlacgv' ); +import zlacpy = require( '@stdlib/lapack/base/zlacpy' ); +import zlaset = require( '@stdlib/lapack/base/zlaset' ); +import zrot = require( '@stdlib/lapack/base/zrot' ); /** * Interface describing the `base` namespace. */ interface Namespace { + /** + * Conjugates each element in a single-precision complex floating-point vector. + * + * @param N - number of indexed elements + * @param cx - input array + * @param strideCX - `cx` stride length + * @returns input array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * ns.clacgv( 3, cx, 1 ); + * + * var z = cx.get( 1 ); + * // returns + * + * var re = realf( z ); + * // returns 3.0 + * + * var im = imagf( z ); + * // returns -4.0 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * + * ns.clacgv.ndarray( 2, cx, 1, 1 ); + * + * var z = cx.get( 1 ); + * // returns + * + * var re = realf( z ); + * // returns 3.0 + * + * var im = imagf( z ); + * // returns -4.0 + */ + clacgv: typeof clacgv; + + /** + * Copies all or part of a matrix `A` to another matrix `B`. + * + * @param order - storage layout of `A` and `B` + * @param uplo - specifies whether to copy the upper or lower triangular/trapezoidal part of matrix `A` + * @param M - number of rows in matrix `A` + * @param N - number of columns in 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 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 realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * var A = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Complex64Array( 4 ); + * + * ns.clacpy( 'row-major', 'all', 2, 2, A, 2, B, 2 ); + * + * var z = B.get( 0 ); + * // returns + * + * var v = realf( z ); + * // returns 1.0 + * + * v = imagf( z ); + * // returns 2.0 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * var A = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * var B = new Complex64Array( 12 ); + * + * ns.clacpy.ndarray( 'all', 2, 2, A, 2, 1, 1, B, 2, 1, 2 ); + * + * var z = B.get( 2 ); + * // returns + * + * var v = realf( z ); + * // returns 3.0 + * + * v = imagf( z ); + * // returns 4.0 + */ + clacpy: typeof clacpy; + + /** + * Sets the off-diagonal elements and the diagonal elements of a single-precision complex floating-point matrix to specified values. + * + * @param order - storage layout of `A` + * @param uplo - specifies whether to set the upper or lower triangular/trapezoidal part of matrix `A` + * @param M - number of rows in matrix `A` + * @param N - number of columns in matrix `A` + * @param alpha - value assigned to off-diagonal elements + * @param beta - value assigned to diagonal elements + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @returns `A` + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var A = new Complex64Array( 4 ); + * + * var alpha = new Complex64( 1.0, 2.0 ); + * var beta = new Complex64( 3.0, 4.0 ); + * + * ns.claset( 'row-major', 'all', 2, 2, alpha, beta, A, 2 ); + * // A => [ 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0 ] + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var A = new Complex64Array( 5 ); + * + * var alpha = new Complex64( 1.0, 2.0 ); + * var beta = new Complex64( 3.0, 4.0 ); + * + * ns.claset.ndarray( 'all', 2, 2, A, 2, 1, 1 ); + * // A => [ 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0 ] + */ + claset: typeof claset; + + /** + * Applies a plane rotation with real cosine and complex sine. + * + * @param N - number of indexed elements + * @param cx - first input array + * @param strideCX - `cx` stride length + * @param cy - second input array + * @param strideCY - `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 Complex64 = require( '@stdlib/complex/float32' ); + * var realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * 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 ] ); + * var s = new Complex64( 0.3, 0.4 ); + * + * ns.crot( 2, cx, 2, cy, 1, 0.8, s ); + * + * var z = cy.get( 0 ); + * // returns + * + * var re = realf( z ); + * // returns ~-1.1 + * + * var im = imagf( z ); + * // returns ~-0.2 + * + * z = cx.get( 0 ); + * // returns + * + * re = realf( z ); + * // returns ~0.8 + * + * im = imagf( z ); + * // returns ~1.6 + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32' ); + * var realf = require( '@stdlib/complex/float32/real' ); + * var imagf = require( '@stdlib/complex/float32/imag' ); + * + * 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 ] ); + * var s = new Complex64( 0.3, 0.4 ); + * + * ns.crot.ndarray( 2, cx, 2, 0, cy, 1, 0, 0.8, s ); + * + * var z = cy.get( 0 ); + * // returns + * + * var re = realf( z ); + * // returns ~-1.1 + * + * var im = imagf( z ); + * // returns ~-0.2 + * + * z = cx.get( 0 ); + * // returns + * + * re = realf( z ); + * // returns ~0.8 + * + * im = imagf( z ); + * // returns ~1.6 + */ + crot: typeof crot; + + /** + * Converts a matrix from row-major layout to column-major layout or vice versa. + * + * @param order - storage layout + * @param M - number of rows in matrix `A` + * @param N - number of columns in 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 out - output matrix + * @param LDO - stride of the first dimension of `out` (a.k.a., leading dimension of the matrix `out`) + * @returns `out` + * + * @example + * var Float64Array = require( `@stdlib/array/float64` ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var out = new Float64Array( 6 ); + * + * out = ns.dgetrans( 'row-major', 2, 3, A, 3, out, 2 ); + * // returns [ 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 ] + * + * @example + * var Float64Array = require( `@stdlib/array/float64` ); + * + * var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var out = new Float64Array( 6 ); + * + * out = ns.dgetrans.ndarray( 2, 3, A, 3, 1, 0, out, 2, 1, 0 ); + * // returns [ 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 ] + */ + dgetrans: typeof dgetrans; + /** * Copies all or part of a matrix `A` to another matrix `B`. * @@ -64,6 +318,39 @@ interface Namespace { */ dlacpy: typeof dlacpy; + /** + * Determines double-precision floating-point machine parameters. + * + * ## Notes + * + * - The `cmach` parameter is a string which specifies the double-precision machine parameter to be returned. The function recognizes the following characters: + * + * - `'E'`/`'e'`: (eps) relative machine precision. + * - `'S'`/`'s'`: (sfmin) safe minimum such that `1/sfmin` does not overflow. + * - `'B'`/`'b'`: (base) base of the machine (also known as the floating-point radix). + * - `'P'`/`'p'`: (prec) `eps*base`. + * - `'N'`/`'n'`: (t) number of (base) digits in the mantissa. + * - `'R'`/`'r'`: (rnd) `1.0` when rounding occurs in addition and `0.0` otherwise. + * - `'M'`/`'m'`: (emin) minimum exponent before (gradual) underflow. + * - `'U'`/`'u'`: (rmin) underflow threshold. + * - `'L'`/`'l'`: (emax) largest exponent before overflow. + * - `'O'`/`'o'`: (rmax) overflow threshold. + * + * @param cmach - specifies the value to be returned + * @returns machine parameter + * + * @example + * var out = ns.dlamch( 'E' ); + * // returns ~1.1102230246251565E-016 + * + * out = ns.dlamch( 'S' ); + * // returns ~2.2250738585072014E-308 + * + * out = ns.dlamch( 'B' ); + * // returns 2.0 + */ + dlamch: typeof dlamch; + /** * Returns an updated sum of squares represented in scaled form. * @@ -158,6 +445,38 @@ interface Namespace { */ dpttrf: typeof dpttrf; + /** + * Converts a matrix from row-major layout to column-major layout or vice versa. + * + * @param order - storage layout + * @param M - number of rows in matrix `A` + * @param N - number of columns in 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 out - output matrix + * @param LDO - stride of the first dimension of `out` (a.k.a., leading dimension of the matrix `out`) + * @returns `out` + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var out = new Float32Array( 6 ); + * + * out = ns.sgetrans( 'row-major', 2, 3, A, 3, out, 2 ); + * // returns [ 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 ] + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var out = new Float32Array( 6 ); + * + * out = ns.sgetrans.ndarray( 2, 3, A, 3, 1, 0, out, 2, 1, 0 ); + * // returns [ 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 ] + */ + sgetrans: typeof sgetrans; + /** * Copies all or part of a matrix `A` to another matrix `B`. * @@ -191,6 +510,41 @@ interface Namespace { */ slacpy: typeof slacpy; + /** + * Performs a series of row interchanges on a matrix `A` using pivot indices stored in `IPIV`. + * + * @param order - storage layout + * @param N - number of columns in `A` + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param k1 - index of first row to interchange + * @param k2 - index of last row to interchange + * @param IPIV - vector of pivot indices + * @param incx - increment between successive values of `IPIV` + * @returns permuted matrix `A` + * + * @example + * var Int32Array = require( '@stdlib/array/int32' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var IPIV = new Int32Array( [ 2, 0, 1 ] ); + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] + * + * ns.slaswp( 'row-major', 2, A, 2, 0, 2, IPIV, 1 ); + * // A => [ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ] + * + * @example + * var Int32Array = require( '@stdlib/array/int32' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var IPIV = new Int32Array( [ 2, 0, 1 ] ); + * var A = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); // => [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] + * + * ns.slaswp.ndarray( 2, A, 2, 1, 0, 0, 2, 1, IPIV, 1, 0 ); + * // A => [ 3.0, 4.0, 1.0, 2.0, 5.0, 6.0 ] + */ + slaswp: typeof slaswp; + /** * Computes the `L * D * L^T` factorization of a real symmetric positive definite tridiagonal matrix `A`. * @@ -220,6 +574,216 @@ interface Namespace { * // E => [ 0.25, ~0.4210 ] */ spttrf: typeof spttrf; + + /** + * Conjugates each element in a double-precision complex floating-point vector. + * + * @param N - number of indexed elements + * @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.zlacgv( 3, zx, 1 ); + * + * var z = zx.get( 1 ); + * // returns + * + * var re = real( z ); + * // returns 3.0 + * + * var im = imag( z ); + * // returns -4.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.zlacgv.ndarray( 2, zx, 1, 1 ); + * + * var z = zx.get( 1 ); + * // returns + * + * var re = real( z ); + * // returns 3.0 + * + * var im = imag( z ); + * // returns -4.0 + */ + zlacgv: typeof zlacgv; + + /** + * Copies all or part of a matrix `A` to another matrix `B`. + * + * @param order - storage layout of `A` and `B` + * @param uplo - specifies whether to copy the upper or lower triangular/trapezoidal part of matrix `A` + * @param M - number of rows in matrix `A` + * @param N - number of columns in 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 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 real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var B = new Complex128Array( 4 ); + * + * ns.zlacpy( 'row-major', 'all', 2, 2, A, 2, B, 2 ); + * + * var z = B.get( 0 ); + * // returns + * + * var v = real( z ); + * // returns 1.0 + * + * v = imag( z ); + * // returns 2.0 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var real = require( '@stdlib/complex/float64/real' ); + * var imag = require( '@stdlib/complex/float64/imag' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 ] ); + * var B = new Complex128Array( 12 ); + * + * ns.zlacpy.ndarray( 'all', 2, 2, A, 2, 1, 1, B, 2, 1, 2 ); + * + * var z = B.get( 2 ); + * // returns + * + * var v = real( z ); + * // returns 3.0 + * + * v = imag( z ); + * // returns 4.0 + */ + zlacpy: typeof zlacpy; + + /** + * Sets the off-diagonal elements and the diagonal elements of a double-precision complex floating-point matrix to specified values. + * + * @param order - storage layout of `A` + * @param uplo - specifies whether to set the upper or lower triangular/trapezoidal part of matrix `A` + * @param M - number of rows in matrix `A` + * @param N - number of columns in matrix `A` + * @param alpha - value assigned to off-diagonal elements + * @param beta - value assigned to diagonal elements + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @returns `A` + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var A = new Complex128Array( 4 ); + * + * var alpha = new Complex128( 1.0, 2.0 ); + * var beta = new Complex128( 3.0, 4.0 ); + * + * ns.zlaset( 'row-major', 'all', 2, 2, alpha, beta, A, 2 ); + * // A => [ 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0 ] + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var A = new Complex128Array( 5 ); + * + * var alpha = new Complex128( 1.0, 2.0 ); + * var beta = new Complex128( 3.0, 4.0 ); + * + * ns.zlaset.ndarray( 'all', 2, 2, A, 2, 1, 1 ); + * // A => [ 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 3.0, 4.0, 1.0, 2.0 ] + */ + zlaset: typeof zlaset; + + /** + * Applies a plane rotation with real cosine and complex sine. + * + * @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 Complex128 = require( '@stdlib/complex/float64' ); + * 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, 7.0, 8.0 ] ); + * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var s = new Complex128( 0.3, 0.4 ); + * + * ns.zrot( 2, zx, 2, zy, 1, 0.8, s ); + * + * var z = zy.get( 0 ); + * // returns + * + * var re = real( z ); + * // returns ~-1.1 + * + * var im = imag( z ); + * // returns ~-0.2 + * + * z = zx.get( 0 ); + * // returns + * + * re = real( z ); + * // returns ~0.8 + * + * im = imag( z ); + * // returns ~1.6 + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64' ); + * 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, 7.0, 8.0 ] ); + * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + * var s = new Complex128( 0.3, 0.4 ); + * + * ns.zrot.ndarray( 2, zx, 2, 0, zy, 1, 0, 0.8, s ); + * + * var z = zy.get( 0 ); + * // returns + * + * var re = real( z ); + * // returns ~-1.1 + * + * var im = imag( z ); + * // returns ~-0.2 + * + * z = zx.get( 0 ); + * // returns + * + * re = real( z ); + * // returns ~0.8 + * + * im = imag( z ); + * // returns ~1.6 + */ + zrot: typeof zrot; } /** 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 62b1fd635cf9..2397f4610076 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 @@ -24,7 +24,6 @@ import cumax = require( '@stdlib/stats/base/cumax' ); import cumaxabs = require( '@stdlib/stats/base/cumaxabs' ); import cumin = require( '@stdlib/stats/base/cumin' ); import cuminabs = require( '@stdlib/stats/base/cuminabs' ); -import dcumaxabs = require( '@stdlib/stats/strided/dcumaxabs' ); import dcumin = require( '@stdlib/stats/base/dcumin' ); import dcuminabs = require( '@stdlib/stats/base/dcuminabs' ); import dists = require( '@stdlib/stats/base/dists' ); @@ -345,36 +344,6 @@ interface Namespace { */ cuminabs: typeof cuminabs; - /** - * Computes the cumulative maximum absolute value of double-precision floating-point strided array elements. - * - * @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, 2.0 ] ); - * var y = new Float64Array( x.length ); - * - * ns.dcumaxabs( x.length, x, 1, y, 1 ); - * // y => [ 1.0, 2.0, 2.0 ] - * - * @example - * var Float64Array = require( '@stdlib/array/float64' ); - * - * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); - * var y = new Float64Array( x.length ); - * - * ns.dcumaxabs.ndarray( x.length, x, 1, 0, y, 1, 0 ); - * // y => [ 1.0, 2.0, 2.0 ] - */ - dcumaxabs: typeof dcumaxabs; - /** * Computes the cumulative minimum of double-precision floating-point strided array elements. *