Update namespace Typescript definitions

Author: Planeshifter

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

@@ -28,15 +28,19 @@ import convertArray = require( '@stdlib/array/convert' );
 import convertArraySame = require( '@stdlib/array/convert-same' );
 import arrayCtors = require( '@stdlib/array/ctors' );
 import DataView = require( '@stdlib/array/dataview' );
+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 Float32Array = require( '@stdlib/array/float32' );
 import Float64Array = require( '@stdlib/array/float64' );
 import iterator2array = require( '@stdlib/array/from-iterator' );
+import incrspace = require( '@stdlib/array/incrspace' );
 import Int8Array = require( '@stdlib/array/int8' );
 import Int16Array = require( '@stdlib/array/int16' );
 import Int32Array = require( '@stdlib/array/int32' );
+import linspace = require( '@stdlib/array/linspace' );
+import logspace = require( '@stdlib/array/logspace' );
 import arrayMinDataType = require( '@stdlib/array/min-dtype' );
 import arrayNextDataType = require( '@stdlib/array/next-dtype' );
 import typedarraypool = require( '@stdlib/array/pool' );
@@ -266,6 +270,36 @@ interface Namespace {
 	*/
 	DataView: typeof DataView;
 
+	/**
+	* Generates an array of linearly spaced dates.
+	*
+	* @param start - start time as either a `Date` object, Unix timestamp, JavaScript timestamp, or date string
+	* @param stop - stop time as either a `Date` object, Unix timestamp, JavaScript timestamp, or date string
+	* @param length - output array length (default: 100)
+	* @param options - function options
+	* @param options.round - specifies how sub-millisecond times should be rounded: [ 'floor', 'ceil', 'round' ] (default: 'floor' )
+	* @throws length argument must a positive integer
+	* @throws must provide valid options
+	* @returns array of dates
+	*
+	* @example
+	* var stop = '2014-12-02T07:00:54.973Z';
+	* var start = new Date( stop ) - 60000;
+	*
+	* var arr = ns.datespace( start, stop, 6 );
+	* // returns [...]
+	*
+	* @example
+	* // Equivalent of Math.ceil():
+	* var arr = ns.datespace( 1417503655000, 1417503655001, 3, { 'round': 'ceil' } );
+	* // returns [...]
+	*
+	* // Equivalent of Math.round():
+	* var arr = ns.datespace( 1417503655000, 1417503655001, 3, { 'round': 'round' } );
+	* // returns [...]
+	*/
+	datespace: typeof datespace;
+
 	/**
 	* Returns the data type of an array.
 	*
@@ -359,6 +393,21 @@ interface Namespace {
 	*/
 	iterator2array: typeof iterator2array;
 
+	/**
+	* Generates a linearly spaced numeric array using a provided increment.
+	*
+	* @param x1 - first array value
+	* @param x2 - array element bound
+	* @param increment - increment (default: 1)
+	* @throws length of created array must be less than `4294967295` (`2**32 - 1`)
+	* @returns linearly spaced numeric array
+	*
+	* @example
+	* var arr = ns.incrspace( 0, 11, 2 );
+	* // returns [ 0, 2, 4, 6, 8, 10 ]
+	*/
+	incrspace: typeof incrspace;
+
 	/**
 	* Typed array constructor which returns a typed array representing an array of twos-complement 8-bit signed integers in the platform byte order.
 	*/
@@ -374,6 +423,36 @@ interface Namespace {
 	*/
 	Int32Array: typeof Int32Array;
 
+	/**
+	* Generates a linearly spaced numeric array.
+	*
+	* @param x1 - first array value
+	* @param x2 - last array value
+	* @param len - length of output array (default: 100)
+	* @throws third argument must be a nonnegative integer
+	* @returns linearly spaced numeric array
+	*
+	* @example
+	* var arr = ns.linspace( 0, 100, 6 );
+	* // returns [ 0, 20, 40, 60, 80, 100 ]
+	*/
+	linspace: typeof linspace;
+
+	/**
+	* Generates a logarithmically spaced numeric array.
+	*
+	* @param a - exponent of start value
+	* @param b - exponent of end value
+	* @param len - length of output array (default: 10)
+	* @throws third argument must be a nonnegative integer
+	* @returns logarithmically spaced numeric array
+	*
+	* @example
+	* var arr = ns.logspace( 0, 2, 6 );
+	* // returns [ 1, ~2.5, ~6.31, ~15.85, ~39.81, 100 ]
+	*/
+	logspace: typeof logspace;
+
 	/**
 	* Returns the minimum array data type of the closest "kind" necessary for storing a provided scalar value.
 	*

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

@@ -26,6 +26,7 @@ import deepEqual = require( '@stdlib/assert/deep-equal' );
 import deepHasOwnProp = require( '@stdlib/assert/deep-has-own-property' );
 import deepHasProp = require( '@stdlib/assert/deep-has-property' );
 import hasArrayBufferSupport = require( '@stdlib/assert/has-arraybuffer-support' );
+import hasArrowFunctionSupport = require( '@stdlib/assert/has-arrow-function-support' );
 import hasAsyncAwaitSupport = require( '@stdlib/assert/has-async-await-support' );
 import hasAsyncIteratorSymbolSupport = require( '@stdlib/assert/has-async-iterator-symbol-support' );
 import hasBigIntSupport = require( '@stdlib/assert/has-bigint-support' );
@@ -76,6 +77,7 @@ import isArrayLike = require( '@stdlib/assert/is-array-like' );
 import isArrayLikeObject = require( '@stdlib/assert/is-array-like-object' );
 import isArrayBuffer = require( '@stdlib/assert/is-arraybuffer' );
 import isArrayBufferView = require( '@stdlib/assert/is-arraybuffer-view' );
+import isArrowFunction = require( '@stdlib/assert/is-arrow-function' );
 import isASCII = require( '@stdlib/assert/is-ascii' );
 import isBetween = require( '@stdlib/assert/is-between' );
 import isBetweenArray = require( '@stdlib/assert/is-between-array' );
@@ -473,6 +475,17 @@ interface Namespace {
 	*/
 	hasArrayBufferSupport: typeof hasArrayBufferSupport;
 
+	/**
+	* Tests for native arrow function support.
+	*
+	* @returns boolean indicating if an environment has native arrow function support
+	*
+	* @example
+	* var bool = ns.hasArrowFunctionSupport();
+	* // returns <boolean>
+	*/
+	hasArrowFunctionSupport: typeof hasArrowFunctionSupport;
+
 	/**
 	* Tests for native `async/await` support.
 	*
@@ -1266,6 +1279,27 @@ interface Namespace {
 	*/
 	isArrayBufferView: typeof isArrayBufferView;
 
+	/**
+	* Tests if a value is an arrow function.
+	*
+	* @param value - value to test
+	* @returns boolean indicating whether value is an arrow function
+	*
+	* @example
+	* var arrow = () => {};
+	* var bool = ns.isArrowFunction( arrow );
+	* // returns true
+	*
+	* @example
+	* function beep() {
+	*     return 'beep';
+	* }
+	
+	* var bool = ns.isArrowFunction( beep );
+	* // returns false
+	*/
+	isArrowFunction: typeof isArrowFunction;
+
 	/**
 	* Tests whether a character belongs to the ASCII character set and whether this is true for all characters in a provided string.
 	*

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

@@ -60,7 +60,7 @@ interface Namespace {
 	* var ctor = require( `@stdlib/buffer/ctor` );
 	*
 	* var b = new ctor( [ 1, 2, 3, 4 ] );
-	* // returns <Buffer>
+	* // returns <ns.Buffer>
 	*/
 	Buffer: typeof Buffer;
 

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

@@ -30,11 +30,12 @@ import float64 = require( '@stdlib/constants/float64' );
 import int8 = require( '@stdlib/constants/int8' );
 import int16 = require( '@stdlib/constants/int16' );
 import int32 = require( '@stdlib/constants/int32' );
-import string = require( '@stdlib/constants/string' );
+import path = require( '@stdlib/constants/path' );
 import time = require( '@stdlib/constants/time' );
 import uint8 = require( '@stdlib/constants/uint8' );
 import uint16 = require( '@stdlib/constants/uint16' );
 import uint32 = require( '@stdlib/constants/uint32' );
+import unicode = require( '@stdlib/constants/unicode' );
 
 /**
 * Interface describing the `constants` namespace.
@@ -86,9 +87,9 @@ interface Namespace {
 	int32: typeof int32;
 
 	/**
-	* Standard string constants.
+	* Standard string path constants.
 	*/
-	string: typeof string;
+	path: typeof path;
 
 	/**
 	* Time constants.
@@ -109,6 +110,11 @@ interface Namespace {
 	* 32-bit unsigned integer mathematical constants.
 	*/
 	uint32: typeof uint32;
+
+	/**
+	* Standard string unicode constants.
+	*/
+	unicode: typeof unicode;
 }
 
 /**

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

@@ -31,6 +31,7 @@ import readJSON = require( '@stdlib/fs/read-json' );
 import readWASM = require( '@stdlib/fs/read-wasm' );
 import rename = require( '@stdlib/fs/rename' );
 import resolveParentPath = require( '@stdlib/fs/resolve-parent-path' );
+import resolveParentPathBy = require( '@stdlib/fs/resolve-parent-path-by' );
 import unlink = require( '@stdlib/fs/unlink' );
 import writeFile = require( '@stdlib/fs/write-file' );
 
@@ -334,6 +335,40 @@ interface Namespace {
 	*/
 	resolveParentPath: typeof resolveParentPath;
 
+	/**
+	* Asynchronously resolves a path according to a predicate function by walking parent directories.
+	*
+	* @param path - path to resolve
+	* @param options - function options
+	* @param options.dir - base directory
+	* @param predicate - predicate function
+	* @param clbk - callback to invoke after resolving a path
+	* @throws must provide valid options
+	*
+	* @example
+	* ns.resolveParentPathBy( 'package.json', predicate, onPath );
+	*
+	* function predicate( path, next ) {
+	*     next( null, true );
+	* }
+	*
+	* function onPath( error, path ) {
+	*     if ( error ) {
+	*         throw error;
+	*     }
+	*     console.log( path );
+	* }
+	*
+	* @example
+	* function predicate() {
+	*     return true;
+	* }
+	*
+	* var path = ns.resolveParentPathBy.sync( 'package.json', predicate );
+	* // e.g., returns '...'
+	*/
+	resolveParentPathBy: typeof resolveParentPathBy;
+
 	/**
 	* Asynchronously removes a directory entry.
 	*

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

@@ -22,7 +22,7 @@
 /* tslint:disable:max-file-line-count */
 
 import assert = require( '@stdlib/math/base/assert' );
-import complex = require( '@stdlib/math/base/complex' );
+import ops = require( '@stdlib/math/base/ops' );
 import special = require( '@stdlib/math/base/special' );
 import tools = require( '@stdlib/math/base/tools' );
 import utils = require( '@stdlib/math/base/utils' );
@@ -37,9 +37,9 @@ interface Namespace {
 	assert: typeof assert;
 
 	/**
-	* Standard library base complex number math functions.
+	* Standard library base math operators.
 	*/
-	complex: typeof complex;
+	ops: typeof ops;
 
 	/**
 	* Standard library base special math functions.

lib/node_modules/@stdlib/ml/incr/docs/types/index.d.ts

@@ -30,44 +30,53 @@ import incrSGDRegression = require( '@stdlib/ml/incr/sgd-regression' );
 */
 interface Namespace {
 	/**
-	* Online learning for classification using stochastic gradient descent (SGD).
+	* Returns an accumulator function which incrementally performs binary classification using stochastic gradient descent (SGD).
 	*
 	* ## Method
 	*
-	* The sub-gradient of the loss function is estimated for each datum and the classification model is updated incrementally, with a decreasing learning rate and regularization of the feature weights based on L2 regularization.
+	* -   The sub-gradient of the loss function is estimated for each datum and the classification model is updated incrementally, with a decreasing learning rate and regularization of model feature weights using L2 regularization.
+	* -   Stochastic gradient descent is sensitive to the scaling of the features. One is advised to either scale each feature to `[0,1]` or `[-1,1]` or to transform each feature into z-scores with zero mean and unit variance. One should keep in mind that the same scaling has to be applied to training data in order to obtain accurate predictions.
+	* -   In general, the more data provided to an accumulator, the more reliable the model predictions.
 	*
 	* ## References
 	*
 	* -   Shalev-Shwartz, S., Singer, Y., Srebro, N., & Cotter, A. (2011). Pegasos: Primal estimated sub-gradient solver for SVM. Mathematical Programming, 127(1), 3–30. doi:10.1007/s10107-010-0420-4
 	*
+	* @param N - number of features
 	* @param options - options object
-	* @param options.epsilon - insensitivity parameter (default: 0.1)
-	* @param options.eta0 - constant learning rate (default: 0.02)
-	* @param options.lambda - regularization parameter (default: 1e-3)
-	* @param options.learningRate - string denoting the learning rate to use. Can be `constant`, `pegasos`, or `basic` (default: 'basic')
-	* @param options.loss - string denoting the loss function to use. Can be `hinge`, `log`, `modifiedHuber`, `perceptron`, or `squaredHinge` (default: 'log')
-	* @param options.intercept - boolean indicating whether to include an intercept (default: true)
+	* @param options.lambda - regularization parameter (default: `1.0e-4`)
+	* @param options.learningRate - learning rate function and associated parameters (default: `['basic']`)
+	* @param options.loss - loss function  (default: `'log'`)
+	* @param options.intercept - boolean indicating whether to include an intercept (default: `true`)
+	* @throws first argument must be a positive integer
 	* @throws must provide valid options
-	* @returns classification model
+	* @returns accumulator function
 	*
 	* @example
-	* var ns.incrBinaryClassification = require( `@stdlib/streams/ml/incr/sgd-classification` );
+	* var Float64Array = require( `@stdlib/array/float64` );
+	* var array = require( `@stdlib/ndarray/array` );
 	*
-	* var accumulator = ns.incrBinaryClassification({
-	*    'intercept': true
-	*    'lambda': 1e-5
+	* // Create an accumulator:
+	* var accumulator = ns.incrBinaryClassification( 3, {
+	*     'intercept': true,
+	*     'lambda': 1.0e-5
 	* });
 	*
-	* // Update model as observations come in:
-	* var y = -1;
-	* var x = [ 2.3, 1.0, 5.0 ];
-	* accumulator( x, y );
+	* // ...
 	*
-	* // Predict new observation:
-	* var yHat = accumulator.predict( x );
+	* // Update the model:
+	* var x = array( new Float64Array( [ 2.3, 1.0, 5.0 ] ) );
+	* var coefs = accumulator( x, 1 );
+	* // returns <ndarray>
 	*
-	* // Retrieve coefficients:
-	* var coefs = accumulator.coefs;
+	* // ...
+	*
+	* // Create a new observation vector:
+	* x = array( new Float64Array( [ 2.3, 5.3, 8.6 ] ) );
+	*
+	* // Predict the response value:
+	* var yhat = accumulator.predict( x );
+	* // returns <ndarray>
 	*/
 	incrBinaryClassification: typeof incrBinaryClassification;