Update namespace TypeScript declarations (#462)

Co-authored-by: Planeshifter <[email protected]>

Author: github-actions[bot]

lib/node_modules/@stdlib/array/docs/types/index.d.ts

@@ -32,6 +32,7 @@ import datespace = require( '@stdlib/array/datespace' );
 import arrayDataType = require( '@stdlib/array/dtype' );
 import arrayDataTypes = require( '@stdlib/array/dtypes' );
 import filledarray = require( '@stdlib/array/filled' );
+import filledarrayBy = require( '@stdlib/array/filled-by' );
 import Float32Array = require( '@stdlib/array/float32' );
 import Float64Array = require( '@stdlib/array/float64' );
 import iterator2array = require( '@stdlib/array/from-iterator' );
@@ -356,10 +357,46 @@ interface Namespace {
 	* var buf = new ArrayBuffer( 32 );
 	* var arr = ns.filledarray( 1.0, buf, 'float32' );
 	* // returns <Float32Array>[ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ]
-	*
 	*/
 	filledarray: typeof filledarray;
 
+	/**
+	* Returns a filled typed array view of an `ArrayBuffer` according to a provided callback function.
+	*
+	* The function recognizes the following data types:
+	*
+	* -   `float64`: double-precision floating-point numbers (IEEE 754)
+	* -   `float32`: single-precision floating-point numbers (IEEE 754)
+	* -   `int32`: 32-bit two's complement signed integers
+	* -   `uint32`: 32-bit unsigned integers
+	* -   `int16`: 16-bit two's complement signed integers
+	* -   `uint16`: 16-bit unsigned integers
+	* -   `int8`: 8-bit two's complement signed integers
+	* -   `uint8`: 8-bit unsigned integers
+	* -   `uint8c`: 8-bit unsigned integers clamped to `0-255`
+	* -   `generic`: generic JavaScript values
+	*
+	* ## Notes
+	*
+	* -   Creating a generic array from an `ArrayBuffer` is **not** supported.
+	*
+	* @param buffer - `ArrayBuffer`
+	* @param dtype - data type
+	* @param clbk - callback function
+	* @param thisArg - callback function execution context
+	* @throws must provide a recognized data type
+	* @returns filled array
+	*
+	* @example
+	* var constantFunction = require( `@stdlib/utils/constant-function` );
+	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	*
+	* var buf = new ArrayBuffer( 32 );
+	* var arr = ns.filledarrayBy( buf, 'float64', constantFunction( 1.0 ) );
+	* // returns <Float64Array>[ 1.0, 1.0, 1.0, 1.0 ]
+	*/
+	filledarrayBy: typeof filledarrayBy;
+
 	/**
 	* Typed array constructor which returns a typed array representing an array of single-precision floating-point numbers in the platform byte order.
 	*/

lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts

@@ -810,7 +810,7 @@ interface Namespace {
 }
 
 /**
-* "Base" (i.e., lower-level) basic linear algebra subprograms (BLAS).
+* Base (i.e., lower-level) basic linear algebra subprograms (BLAS).
 */
 declare var ns: Namespace;
 

lib/node_modules/@stdlib/blas/docs/types/index.d.ts

@@ -35,7 +35,7 @@ import sswap = require( '@stdlib/blas/sswap' );
 */
 interface Namespace {
 	/**
-	* "Base" (i.e., lower-level) basic linear algebra subprograms (BLAS).
+	* Base (i.e., lower-level) basic linear algebra subprograms (BLAS).
 	*/
 	base: typeof base;
 
@@ -89,7 +89,7 @@ interface Namespace {
 	dswap: typeof dswap;
 
 	/**
-	* Standard library extended BLAS.
+	* Extended BLAS.
 	*/
 	ext: typeof ext;
 

lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts

@@ -3273,7 +3273,7 @@ interface Namespace {
 }
 
 /**
-* Base (i.e., lower-level) extensions to basic linear algebra subroutines (BLAS).
+* Extended base (i.e., lower-level) basic linear algebra subroutines (BLAS).
 */
 declare var ns: Namespace;
 

lib/node_modules/@stdlib/blas/ext/docs/types/index.d.ts

@@ -28,7 +28,7 @@ import base = require( '@stdlib/blas/ext/base' );
 */
 interface Namespace {
 	/**
-	* Base (i.e., lower-level) extensions to basic linear algebra subroutines (BLAS).
+	* Extended base (i.e., lower-level) basic linear algebra subroutines (BLAS).
 	*/
 	base: typeof base;
 }

lib/node_modules/@stdlib/constants/docs/types/index.d.ts

@@ -87,7 +87,7 @@ interface Namespace {
 	int32: typeof int32;
 
 	/**
-	* Path constants.
+	* Standard string path constants.
 	*/
 	path: typeof path;
 
@@ -112,7 +112,7 @@ interface Namespace {
 	uint32: typeof uint32;
 
 	/**
-	* String unicode constants.
+	* Standard string unicode constants.
 	*/
 	unicode: typeof unicode;
 }

lib/node_modules/@stdlib/math/base/assert/docs/types/index.d.ts

@@ -572,7 +572,7 @@ interface Namespace {
 }
 
 /**
-* Base (i.e., lower-level) math assertion utilities.
+* Base mathematical assertion utilities.
 */
 declare var ns: Namespace;
 

lib/node_modules/@stdlib/math/base/docs/types/index.d.ts

@@ -32,17 +32,17 @@ import utils = require( '@stdlib/math/base/utils' );
 */
 interface Namespace {
 	/**
-	* Base math assertion utilities.
+	* Base mathematical assertion utilities.
 	*/
 	assert: typeof assert;
 
 	/**
-	* Base math operators.
+	* Base (i.e., lower-level) math operators.
 	*/
 	ops: typeof ops;
 
 	/**
-	* Base special math functions.
+	* Base (i.e., lower-level) special math functions.
 	*/
 	special: typeof special;
 

lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts

@@ -21,16 +21,83 @@
 /* tslint:disable:max-line-length */
 /* tslint:disable:max-file-line-count */
 
+import add = require( '@stdlib/math/base/ops/add' );
+import addf = require( '@stdlib/math/base/ops/addf' );
 import cadd = require( '@stdlib/math/base/ops/cadd' );
 import cdiv = require( '@stdlib/math/base/ops/cdiv' );
 import cmul = require( '@stdlib/math/base/ops/cmul' );
 import cneg = require( '@stdlib/math/base/ops/cneg' );
 import csub = require( '@stdlib/math/base/ops/csub' );
+import imul = require( '@stdlib/math/base/ops/imul' );
+import imuldw = require( '@stdlib/math/base/ops/imuldw' );
+import mul = require( '@stdlib/math/base/ops/mul' );
+import sub = require( '@stdlib/math/base/ops/sub' );
+import subf = require( '@stdlib/math/base/ops/subf' );
+import umul = require( '@stdlib/math/base/ops/umul' );
+import umuldw = require( '@stdlib/math/base/ops/umuldw' );
 
 /**
 * Interface describing the `ops` namespace.
 */
 interface Namespace {
+	/**
+	* Computes the sum of two double-precision floating-point numbers `x` and `y`.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @returns sum
+	*
+	* @example
+	* var v = ns.add( -1.0, 5.0 );
+	* // returns 4.0
+	*
+	* @example
+	* var v = ns.add( 2.0, 5.0 );
+	* // returns 7.0
+	*
+	* @example
+	* var v = ns.add( 0.0, 5.0 );
+	* // returns 5.0
+	*
+	* @example
+	* var v = ns.add( -0.0, 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.add( NaN, NaN );
+	* // returns NaN
+	*/
+	add: typeof add;
+
+	/**
+	* Computes the sum of two single-precision floating-point numbers `x` and `y`.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @returns sum
+	*
+	* @example
+	* var v = ns.addf( -1.0, 5.0 );
+	* // returns 4.0
+	*
+	* @example
+	* var v = ns.addf( 2.0, 5.0 );
+	* // returns 7.0
+	*
+	* @example
+	* var v = ns.addf( 0.0, 5.0 );
+	* // returns 5.0
+	*
+	* @example
+	* var v = ns.addf( -0.0, 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.addf( NaN, NaN );
+	* // returns NaN
+	*/
+	addf: typeof addf;
+
 	/**
 	* Adds two complex numbers.
 	*
@@ -111,6 +178,153 @@ interface Namespace {
 	// returns [ 7.0, 2.0 ]
 	*/
 	csub: typeof csub;
+
+	/**
+	* Performs C-like multiplication of two signed 32-bit integers.
+	*
+	* @param a - signed 32-bit integer
+	* @param b - signed 32-bit integer
+	* @returns product
+	*
+	* @example
+	* var v = ns.imul( -10|0, 4|0 );
+	* // returns -40
+	*/
+	imul: typeof imul;
+
+	/**
+	* Performs multiplication of two signed 32-bit integers and returns an array of two signed 32-bit integers which represents the signed 64-bit integer product.
+	*
+	* ## Notes
+	*
+	* -   When computing the product of 32-bit integer values in double-precision floating-point format (the default JavaScript numeric data type), computing the double word product is necessary in order to avoid exceeding the maximum safe double-precision floating-point integer value.
+	*
+	* @param a - integer
+	* @param b - integer
+	* @returns output array
+	*
+	* @example
+	* var v = ns.imuldw( 0xAAAAAAAA, 0x55555555 );
+	* // returns [ -477218589, 1908874354 ]
+	*/
+	imuldw: typeof imuldw;
+
+	/**
+	* Multiplies two double-precision floating-point numbers `x` and `y`.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @returns result
+	*
+	* @example
+	* var v = ns.mul( -1.0, 5.0 );
+	* // returns -5.0
+	*
+	* @example
+	* var v = ns.mul( 2.0, 5.0 );
+	* // returns 10.0
+	*
+	* @example
+	* var v = ns.mul( 0.0, 5.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.mul( -0.0, 0.0 );
+	* // returns -0.0
+	*
+	* @example
+	* var v = ns.mul( NaN, NaN );
+	* // returns NaN
+	*/
+	mul: typeof mul;
+
+	/**
+	* Subtracts two double-precision floating-point numbers `x` and `y`.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @returns result
+	*
+	* @example
+	* var v = ns.sub( -1.0, 5.0 );
+	* // returns -6.0
+	*
+	* @example
+	* var v = ns.sub( 2.0, 5.0 );
+	* // returns -3.0
+	*
+	* @example
+	* var v = ns.sub( 0.0, 5.0 );
+	* // returns -5.0
+	*
+	* @example
+	* var v = ns.sub( -0.0, 0.0 );
+	* // returns -0.0
+	*
+	* @example
+	* var v = ns.sub( NaN, NaN );
+	* // returns NaN
+	*/
+	sub: typeof sub;
+
+	/**
+	* Subtracts two single-precision floating-point numbers `x` and `y`.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @returns result
+	*
+	* @example
+	* var v = ns.subf( -1.0, 5.0 );
+	* // returns -6.0
+	*
+	* @example
+	* var v = ns.subf( 2.0, 5.0 );
+	* // returns -3.0
+	*
+	* @example
+	* var v = ns.subf( 0.0, 5.0 );
+	* // returns -5.0
+	*
+	* @example
+	* var v = ns.subf( -0.0, 0.0 );
+	* // returns -0.0
+	*
+	* @example
+	* var v = ns.subf( NaN, NaN );
+	* // returns NaN
+	*/
+	subf: typeof subf;
+
+	/**
+	* Performs C-like multiplication of two unsigned 32-bit integers.
+	*
+	* @param a - unsigned 32-bit integer
+	* @param b - Unsigned 32-bit integer
+	* @returns product
+	*
+	* @example
+	* var v = ns.umul( 10>>>0, 4>>>0 );
+	* // returns 40
+	*/
+	umul: typeof umul;
+
+	/**
+	* Performs multiplication of two unsigned 32-bit integers and returns an array of two unsigned 32-bit integers which represents the unsigned 64-bit integer product.
+	*
+	* ## Notes
+	*
+	* -   When computing the product of 32-bit integer values in double-precision floating-point format (the default JavaScript numeric data type), computing the double word product is necessary in order to avoid exceeding the maximum safe double-precision floating-point integer value.
+	*
+	* @param a - integer
+	* @param b - integer
+	* @returns double word product (in big endian order; i.e., the first element corresponds to the most significant bits and the second element to the least significant bits)
+	*
+	* @example
+	* var v = ns.umuldw( 0xAAAAAAAA, 0x55555555 );
+	* // returns [ 954437176, 1908874354 ]
+	*/
+	umuldw: typeof umuldw;
 }
 
 /**

lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts

@@ -2559,7 +2559,7 @@ interface Namespace {
 	fallingFactorial: typeof fallingFactorial;
 
 	/**
-	* Base fast math special functions.
+	* Fast math special functions.
 	*/
 	fast: typeof fast;