diff --git a/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.js b/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.js
index ff62a0455a27..c216a025775f 100644
--- a/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.js
+++ b/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.js
@@ -114,12 +114,6 @@ function assign( x, searchElement, fromIndex, out ) {
if ( !isndarrayLike( x ) ) {
throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
}
- if ( nargs < 2 ) {
- throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
- }
- if ( nargs < 3 ) {
- throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', fromIndex ) );
- }
// Resolve input ndarray meta data:
dt = getDType( x );
ord = getOrder( x );
@@ -139,8 +133,11 @@ function assign( x, searchElement, fromIndex, out ) {
hasOptions = false;
// Case: assign( x, search_element, out )
- if ( nargs === 3 ) {
+ if ( nargs <= 3 ) {
o = fromIndex;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', o ) );
+ }
}
// Case: assign( x, search_element, ???, ??? )
else if ( nargs === 4 ) {
@@ -165,6 +162,9 @@ function assign( x, searchElement, fromIndex, out ) {
// Case: assign( x, search_element, out, options )
else {
o = fromIndex;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', o ) );
+ }
options = out;
hasOptions = true;
}
@@ -185,6 +185,9 @@ function assign( x, searchElement, fromIndex, out ) {
throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
}
o = out;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Fourth argument must be an ndarray. Value: `%s`.', o ) );
+ }
options = arguments[ 4 ];
hasOptions = true;
}
diff --git a/lib/node_modules/@stdlib/blas/ext/index-of/test/test.assign.js b/lib/node_modules/@stdlib/blas/ext/index-of/test/test.assign.js
index 97975eba5868..9067356c4f78 100644
--- a/lib/node_modules/@stdlib/blas/ext/index-of/test/test.assign.js
+++ b/lib/node_modules/@stdlib/blas/ext/index-of/test/test.assign.js
@@ -490,7 +490,41 @@ tape( 'the function throws an error if provided a first argument which is a zero
}
});
-tape( 'the function throws an error if provided a third argument which is not an ndarray-like object, an integer, or an object', function test( t ) {
+tape( 'the function throws an error if provided a fromIndex argument which is not an ndarray-like object, an integer, or an object', function test( t ) {
+ var values;
+ var i;
+ var x;
+ var y;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ y = zeros( [], {
+ 'dtype': 'generic'
+ });
+ values = [
+ '5',
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ indexOf( x, scalar2ndarray( 2.0 ), value, y );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a fromIndex argument which is not an ndarray-like object, an integer, or an object (options)', function test( t ) {
var values;
var i;
var x;
diff --git a/lib/node_modules/@stdlib/blas/ext/last-index-of/lib/assign.js b/lib/node_modules/@stdlib/blas/ext/last-index-of/lib/assign.js
index c7b76d21f878..034248d20b1a 100644
--- a/lib/node_modules/@stdlib/blas/ext/last-index-of/lib/assign.js
+++ b/lib/node_modules/@stdlib/blas/ext/last-index-of/lib/assign.js
@@ -114,12 +114,6 @@ function assign( x, searchElement, fromIndex, out ) {
if ( !isndarrayLike( x ) ) {
throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
}
- if ( nargs < 2 ) {
- throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
- }
- if ( nargs < 3 ) {
- throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', fromIndex ) );
- }
// Resolve input ndarray meta data:
dt = getDType( x );
ord = getOrder( x );
@@ -139,8 +133,11 @@ function assign( x, searchElement, fromIndex, out ) {
hasOptions = false;
// Case: assign( x, search_element, out )
- if ( nargs === 3 ) {
+ if ( nargs <= 3 ) {
o = fromIndex;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', o ) );
+ }
}
// Case: assign( x, search_element, ???, ??? )
else if ( nargs === 4 ) {
@@ -165,6 +162,9 @@ function assign( x, searchElement, fromIndex, out ) {
// Case: assign( x, search_element, out, options )
else {
o = fromIndex;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', o ) );
+ }
options = out;
hasOptions = true;
}
@@ -185,6 +185,9 @@ function assign( x, searchElement, fromIndex, out ) {
throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
}
o = out;
+ if ( !isndarrayLike( o ) ) {
+ throw new TypeError( format( 'invalid argument. Fourth argument must be an ndarray. Value: `%s`.', o ) );
+ }
options = arguments[ 4 ];
hasOptions = true;
}
diff --git a/lib/node_modules/@stdlib/blas/ext/last-index-of/test/test.assign.js b/lib/node_modules/@stdlib/blas/ext/last-index-of/test/test.assign.js
index c4135da1f879..2d7f744d41dd 100644
--- a/lib/node_modules/@stdlib/blas/ext/last-index-of/test/test.assign.js
+++ b/lib/node_modules/@stdlib/blas/ext/last-index-of/test/test.assign.js
@@ -490,7 +490,41 @@ tape( 'the function throws an error if provided a first argument which is a zero
}
});
-tape( 'the function throws an error if provided a third argument which is not an ndarray-like object, an integer, or an object', function test( t ) {
+tape( 'the function throws an error if provided a fromIndex argument which is not an ndarray-like object, an integer, or an object', function test( t ) {
+ var values;
+ var i;
+ var x;
+ var y;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ y = zeros( [], {
+ 'dtype': 'generic'
+ });
+ values = [
+ '5',
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ lastIndexOf( x, scalar2ndarray( 2.0 ), value, y );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a fromIndex argument which is not an ndarray-like object, an integer, or an object (options)', function test( t ) {
var values;
var i;
var x;
diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.for_each.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.for_each.js
new file mode 100644
index 000000000000..39c99d237837
--- /dev/null
+++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.for_each.js
@@ -0,0 +1,188 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var hasProp = require( '@stdlib/assert/has-property' );
+var isFunction = require( '@stdlib/assert/is-function' );
+var namedtypedtuple = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof namedtypedtuple, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'a tuple has a `forEach` method', function test( t ) {
+ var Point;
+ var p;
+
+ Point = namedtypedtuple( [ 'x', 'y' ] );
+ p = new Point();
+
+ t.strictEqual( hasProp( p, 'forEach' ), true, 'returns expected value' );
+ t.strictEqual( isFunction( p.forEach ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the method throws an error if invoked with a `this` context which is not a tuple instance', function test( t ) {
+ var values;
+ var Point;
+ var p;
+ var i;
+
+ Point = namedtypedtuple( [ 'x', 'y' ] );
+ p = new Point( [ 1, 2 ] );
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ {},
+ [],
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[i] ), TypeError, 'throws an error when provided '+values[i] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ return p.forEach.call( value, fcn );
+ };
+ }
+
+ function fcn( v ) {
+ return v;
+ }
+});
+
+tape( 'the method throws an error if provided a first argument which is not a function', function test( t ) {
+ var values;
+ var Point;
+ var p;
+ var i;
+
+ Point = namedtypedtuple( [ 'x', 'y' ] );
+ p = new Point( [ 1, 2 ] );
+
+ values = [
+ '5',
+ 3.14,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ {},
+ []
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[i] ), TypeError, 'throws an error when provided '+values[i] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ return p.forEach( value );
+ };
+ }
+});
+
+tape( 'the method returns `undefined`', function test( t ) {
+ var Point;
+ var out;
+ var p;
+
+ Point = namedtypedtuple( [ 'x', 'y' ] );
+ p = new Point( [ 10, 20 ] );
+ out = p.forEach( fcn );
+
+ t.strictEqual( out, void 0, 'returns expected value' );
+ t.end();
+
+ function fcn( v ) {
+ return v;
+ }
+});
+
+tape( 'the method invokes a provided function for each element in a tuple', function test( t ) {
+ var fieldNames;
+ var indices;
+ var values;
+ var tuples;
+ var Point;
+ var p;
+
+ indices = [];
+ values = [];
+ fieldNames = [];
+ tuples = [];
+
+ Point = namedtypedtuple( [ 'x', 'y', 'z' ] );
+ p = new Point( [ 1, 2, 3 ] );
+ p.forEach( fcn );
+
+ t.deepEqual( values, [ 1, 2, 3 ], 'returns expected values' );
+ t.deepEqual( indices, [ 0, 1, 2 ], 'returns expected indices' );
+ t.deepEqual( fieldNames, [ 'x', 'y', 'z' ], 'returns expected field names' );
+ t.strictEqual( tuples[ 0 ], p, 'returns expected tuple reference' );
+ t.strictEqual( tuples[ 1 ], p, 'returns expected tuple reference' );
+ t.strictEqual( tuples[ 2 ], p, 'returns expected tuple reference' );
+
+ t.end();
+
+ function fcn( v, i, fieldName, tuple ) {
+ values.push( v );
+ indices.push( i );
+ fieldNames.push( fieldName );
+ tuples.push( tuple );
+ }
+});
+
+tape( 'the method supports providing an execution context', function test( t ) {
+ var Point;
+ var ctx;
+ var p;
+
+ ctx = {
+ 'count': 0
+ };
+ Point = namedtypedtuple( [ 'x', 'y', 'z' ] );
+ p = new Point( [ 1, 2, 3 ] );
+ p.forEach( fcn, ctx );
+
+ t.strictEqual( ctx.count, 3, 'returns expected value' );
+
+ t.end();
+
+ function fcn() {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ }
+});
diff --git a/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.to_string.js b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.to_string.js
new file mode 100644
index 000000000000..ef8d8adddb96
--- /dev/null
+++ b/lib/node_modules/@stdlib/dstructs/named-typed-tuple/test/test.to_string.js
@@ -0,0 +1,121 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isFunction = require( '@stdlib/assert/is-function' );
+var namedtypedtuple = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof namedtypedtuple, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'a tuple has a `toString` method', function test( t ) {
+ var Point;
+ var p;
+
+ Point = namedtypedtuple( [ 'x', 'y' ], {
+ 'name': 'Point'
+ });
+ p = new Point( [ 10, 20 ] );
+
+ t.strictEqual( hasOwnProp( p, 'toString' ), true, 'returns expected value' );
+ t.strictEqual( isFunction( p.toString ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the method throws an error if invoked with a `this` context which is not a tuple instance', function test( t ) {
+ var values;
+ var Point;
+ var p;
+ var i;
+
+ Point = namedtypedtuple( [ 'x', 'y' ], {
+ 'name': 'Point'
+ });
+ p = new Point( [ 10, 20 ] );
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ {},
+ [],
+ function noop() {},
+ {
+ 'name': 'Bob'
+ }
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[i] ), TypeError, 'throws an error when provided '+values[i] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ return p.toString.call( value );
+ };
+ }
+});
+
+tape( 'the method returns a string representation for a tuple with one field', function test( t ) {
+ var expected;
+ var Single;
+ var actual;
+ var s;
+
+ Single = namedtypedtuple( [ 'id' ], {
+ 'name': 'Single'
+ });
+ s = new Single( [ 12345 ] );
+
+ expected = 'Single(id=12345)';
+ actual = s.toString();
+
+ t.strictEqual( actual, expected, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the method returns a string representation of a tuple with multiple fields', function test( t ) {
+ var expected;
+ var actual;
+ var Point;
+ var p;
+
+ Point = namedtypedtuple( [ 'price', 'quantity' ] );
+ p = new Point( [ 123456.789, 9876 ] );
+
+ expected = 'tuple(price=123456.789, quantity=9876)';
+ actual = p.toString();
+
+ t.strictEqual( actual, expected, 'returns expected value' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/atan/package.json b/lib/node_modules/@stdlib/math/base/special/atan/package.json
index 19d6e343e3be..ff6a18f59a9a 100644
--- a/lib/node_modules/@stdlib/math/base/special/atan/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/atan/package.json
@@ -68,5 +68,83 @@
"trigonometry",
"polyfill",
"ponyfill"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "atan",
+ "alias": "atan",
+ "pkg_desc": "compute the arctangent (in radians) of a double-precision floating-point number",
+ "desc": "computes the arctangent (in radians) of a double-precision floating-point number",
+ "short_desc": "arctangent",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -100,
+ 100
+ ]
+ },
+ "example_values": [
+ 0.33,
+ -57.2,
+ 1.2,
+ -0.77,
+ 1000,
+ -3.41,
+ 8.9,
+ -250.5,
+ 0.01,
+ 42,
+ -19.7,
+ 73.6,
+ -0.58,
+ 5.5,
+ -99.9,
+ 7.25,
+ -12.3,
+ 0,
+ 315.8,
+ -1.1
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "arctangent (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "atan",
+ "arctangent",
+ "tangent",
+ "tan",
+ "arc",
+ "inverse"
+ ],
+ "extra_keywords": [
+ "math.atan"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/atand/package.json b/lib/node_modules/@stdlib/math/base/special/atand/package.json
index 98eda3a37b8e..b14c45120b40 100644
--- a/lib/node_modules/@stdlib/math/base/special/atand/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/atand/package.json
@@ -63,5 +63,81 @@
"trig",
"trigonometry",
"radians"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "atand",
+ "alias": "atand",
+ "pkg_desc": "compute the arctangent (in degrees) of a double-precision floating-point number",
+ "desc": "computes the arctangent (in degrees) of a double-precision floating-point number",
+ "short_desc": "arctangent",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -100,
+ 100
+ ]
+ },
+ "example_values": [
+ 180.2,
+ -3.7,
+ 0.42,
+ -98.5,
+ 5.4,
+ -0.06,
+ 73.1,
+ -41.3,
+ 9.9,
+ -12.2,
+ 0,
+ 31.8,
+ -7.5,
+ 250.7,
+ -0.9,
+ 14.2,
+ -66.4,
+ 1.01,
+ 1000,
+ -325.6
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "arctangent (in degrees)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "degree",
+ "arctangent",
+ "tangent",
+ "inverse"
+ ],
+ "extra_keywords": [
+ "math.atan"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/atandf/package.json b/lib/node_modules/@stdlib/math/base/special/atandf/package.json
index 0dc84efc59f5..73b2016c0154 100644
--- a/lib/node_modules/@stdlib/math/base/special/atandf/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/atandf/package.json
@@ -63,5 +63,81 @@
"trig",
"trigonometry",
"radians"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "atand",
+ "alias": "atandf",
+ "pkg_desc": "compute the arctangent (in degrees) of a single-precision floating-point number",
+ "desc": "computes the arctangent (in degrees) of a single-precision floating-point number",
+ "short_desc": "arctangent",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -50,
+ 50
+ ]
+ },
+ "example_values": [
+ 0.21,
+ -77.3,
+ 6.4,
+ -0.18,
+ 19.7,
+ -41.2,
+ 2.05,
+ -9.9,
+ 73.3,
+ -25.6,
+ 0,
+ 38.9,
+ -4.7,
+ 101.5,
+ -12.1,
+ 5.8,
+ -33.4,
+ 1.03,
+ 250.2,
+ -150.7
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "arctangent (in degrees)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ }
+ },
+ "keywords": [
+ "degree",
+ "arctangent",
+ "tangent",
+ "inverse"
+ ],
+ "extra_keywords": [
+ "math.atan"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/atanf/package.json b/lib/node_modules/@stdlib/math/base/special/atanf/package.json
index 02c77bcd3364..abdbda9064e7 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanf/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/atanf/package.json
@@ -66,5 +66,81 @@
"trigonometry",
"radians",
"angle"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "atan",
+ "alias": "atanf",
+ "pkg_desc": "compute the arctangent (in radians) of a single-precision floating-point number",
+ "desc": "computes the arctangent (in radians) of a single-precision floating-point number",
+ "short_desc": "arctangent",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -50,
+ 50
+ ]
+ },
+ "example_values": [
+ -0.91,
+ 23.4,
+ -11.7,
+ 0.03,
+ 77.8,
+ -2.2,
+ 5.6,
+ -39.1,
+ 1.01,
+ -0.47,
+ 14.9,
+ -8.3,
+ 0,
+ 3.33,
+ -25.6,
+ 6.7,
+ -4.2,
+ 41.5,
+ -19.9,
+ 95.2
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "arctangent (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ }
+ },
+ "keywords": [
+ "atanf",
+ "arctangent",
+ "tangent",
+ "inverse"
+ ],
+ "extra_keywords": [
+ "math.atan"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/atanh/package.json b/lib/node_modules/@stdlib/math/base/special/atanh/package.json
index e8640bea462d..1838de548eb9 100644
--- a/lib/node_modules/@stdlib/math/base/special/atanh/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/atanh/package.json
@@ -68,5 +68,82 @@
"angle",
"polyfill",
"ponyfill"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "atanh",
+ "alias": "atanh",
+ "pkg_desc": "compute the hyperbolic arctangent of a double-precision floating-point number",
+ "desc": "computes the hyperbolic arctangent of a double-precision floating-point number",
+ "short_desc": "hyperbolic arctangent",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": -1,
+ "max": 1
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -0.95,
+ 0.95
+ ]
+ },
+ "example_values": [
+ -0.99,
+ 0.72,
+ -0.15,
+ 0.93,
+ -0.61,
+ 0.05,
+ -0.84,
+ 0.31,
+ -0.47,
+ 0.12,
+ -0.72,
+ 0.6,
+ -0.03,
+ 0.89,
+ -0.27,
+ 0,
+ 0.41,
+ -0.66,
+ 0.18,
+ -0.91
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "hyperbolic arctangent",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "atanh",
+ "hyperbolic",
+ "inverse",
+ "tangent",
+ "tan"
+ ],
+ "extra_keywords": [
+ "math.atanh"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/avercos/package.json b/lib/node_modules/@stdlib/math/base/special/avercos/package.json
index 5e9ef1d326fd..f09f5df300ef 100644
--- a/lib/node_modules/@stdlib/math/base/special/avercos/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/avercos/package.json
@@ -73,5 +73,90 @@
"trigonometry",
"radians",
"angle"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "avercos",
+ "alias": "avercos",
+ "pkg_desc": "compute the inverse versed cosine (in radians) of a double-precision floating-point number",
+ "desc": "computes the inverse versed cosine (in radians) of a double-precision floating-point number",
+ "short_desc": "inverse versed cosine",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": -2,
+ "max": 0
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -2,
+ 0
+ ]
+ },
+ "example_values": [
+ -0.04,
+ -1.7,
+ -0.96,
+ -0.25,
+ -1.13,
+ -0.62,
+ -1.91,
+ -0.37,
+ -1.48,
+ -0.83,
+ -0.12,
+ -1.23,
+ -0.57,
+ -1.03,
+ -0.7,
+ -1.66,
+ -0.19,
+ -1.34,
+ -0.49,
+ -1.85
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "inverse versed cosine (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "avercos",
+ "avercosin",
+ "avercosine",
+ "arcvercos",
+ "arcvercosin",
+ "versed cosine",
+ "avercosinus",
+ "avcs",
+ "arc",
+ "versed",
+ "cosine",
+ "cos",
+ "acos"
+ ],
+ "extra_keywords": [
+ "math.acos"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/avercosf/package.json b/lib/node_modules/@stdlib/math/base/special/avercosf/package.json
index cc31add04359..15f861f6fb43 100644
--- a/lib/node_modules/@stdlib/math/base/special/avercosf/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/avercosf/package.json
@@ -73,5 +73,90 @@
"trigonometry",
"radians",
"angle"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "avercos",
+ "alias": "avercosf",
+ "pkg_desc": "compute the inverse versed cosine (in radians) of a single-precision floating-point number",
+ "desc": "computes the inverse versed cosine (in radians) of a single-precision floating-point number",
+ "short_desc": "inverse versed cosine",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ },
+ "domain": [
+ {
+ "min": -2,
+ "max": 0
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -2,
+ 0
+ ]
+ },
+ "example_values": [
+ -0.08,
+ -1.64,
+ -0.91,
+ -0.21,
+ -1.09,
+ -0.59,
+ -1.87,
+ -0.33,
+ -1.42,
+ -0.79,
+ -0.16,
+ -1.19,
+ -0.53,
+ -1.01,
+ -0.73,
+ -1.71,
+ -0.27,
+ -1.29,
+ -0.46,
+ -1.81
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "inverse versed cosine (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ }
+ },
+ "keywords": [
+ "avercos",
+ "avercosin",
+ "avercosine",
+ "arcvercos",
+ "arcvercosin",
+ "versed cosine",
+ "avercosinus",
+ "avcs",
+ "arc",
+ "versed",
+ "cosine",
+ "cos",
+ "acos"
+ ],
+ "extra_keywords": [
+ "math.acos"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/aversin/package.json b/lib/node_modules/@stdlib/math/base/special/aversin/package.json
index 72a55b86348a..afe586850c5f 100644
--- a/lib/node_modules/@stdlib/math/base/special/aversin/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/aversin/package.json
@@ -74,5 +74,91 @@
"trigonometry",
"radians",
"angle"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "aversin",
+ "alias": "aversin",
+ "pkg_desc": "compute the inverse versed sine (in radians) of a double-precision floating-point number",
+ "desc": "computes the inverse versed sine (in radians) of a double-precision floating-point number",
+ "short_desc": "inverse versed sine",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": 0,
+ "max": 2
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ 0,
+ 2
+ ]
+ },
+ "example_values": [
+ 0.06,
+ 1.72,
+ 0.94,
+ 0.18,
+ 1.07,
+ 0.6,
+ 1.92,
+ 0.29,
+ 1.37,
+ 0.81,
+ 0.14,
+ 1.21,
+ 0.55,
+ 1.02,
+ 0.76,
+ 1.68,
+ 0.23,
+ 1.31,
+ 0.47,
+ 1.84
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "inverse versed sine (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "aversin",
+ "aversine",
+ "arcversin",
+ "arcversine",
+ "versed sine",
+ "aversinus",
+ "arcvers",
+ "avers",
+ "aver",
+ "arc",
+ "versed",
+ "sine",
+ "sin",
+ "acos"
+ ],
+ "extra_keywords": [
+ "math.acos"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/aversinf/package.json b/lib/node_modules/@stdlib/math/base/special/aversinf/package.json
index 168b180eed54..f913ea23fb0c 100644
--- a/lib/node_modules/@stdlib/math/base/special/aversinf/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/aversinf/package.json
@@ -74,5 +74,91 @@
"trigonometry",
"radians",
"angle"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "aversin",
+ "alias": "aversinf",
+ "pkg_desc": "compute the inverse versed sine (in radians) of a single-precision floating-point number",
+ "desc": "computes the inverse versed sine (in radians) of a single-precision floating-point number",
+ "short_desc": "inverse versed sine",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ },
+ "domain": [
+ {
+ "min": 0,
+ "max": 2
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ 0,
+ 2
+ ]
+ },
+ "example_values": [
+ 0.09,
+ 1.69,
+ 0.9,
+ 0.2,
+ 1.04,
+ 0.58,
+ 1.86,
+ 0.31,
+ 1.4,
+ 0.77,
+ 0.17,
+ 1.16,
+ 0.51,
+ 0.99,
+ 0.72,
+ 1.74,
+ 0.25,
+ 1.27,
+ 0.43,
+ 1.79
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "inverse versed sine (in radians)",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ }
+ },
+ "keywords": [
+ "aversin",
+ "aversine",
+ "arcversin",
+ "arcversine",
+ "versed sine",
+ "aversinus",
+ "arcvers",
+ "avers",
+ "aver",
+ "arc",
+ "versed",
+ "sine",
+ "sin",
+ "acos"
+ ],
+ "extra_keywords": [
+ "math.acos"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj0/package.json b/lib/node_modules/@stdlib/math/base/special/besselj0/package.json
index 4d83b6014de1..14d194cf626d 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj0/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/besselj0/package.json
@@ -61,5 +61,77 @@
"bessel",
"j0",
"number"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "besselj0",
+ "alias": "besselj0",
+ "pkg_desc": "compute the Bessel function of the first kind of order zero for a double-precision floating-point number",
+ "desc": "computes the Bessel function of the first kind of order zero for a double-precision floating-point number",
+ "short_desc": "Bessel function of the first kind of order zero",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -100,
+ 100
+ ]
+ },
+ "example_values": [
+ -250.3,
+ 0.12,
+ 3.7,
+ -5.9,
+ 10.4,
+ -1.01,
+ 42,
+ -77.6,
+ 0,
+ 6.28,
+ -19.1,
+ 85.2,
+ -33.3,
+ 1.5,
+ -0.43,
+ 9.81,
+ -123.4,
+ 57.9,
+ -2.7,
+ 1000
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "evaluated Bessel function",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "bessel",
+ "j0"
+ ],
+ "extra_keywords": []
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/besselj1/package.json b/lib/node_modules/@stdlib/math/base/special/besselj1/package.json
index 45436d355a66..07f60e2c3923 100644
--- a/lib/node_modules/@stdlib/math/base/special/besselj1/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/besselj1/package.json
@@ -61,5 +61,77 @@
"bessel",
"j1",
"number"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "besselj1",
+ "alias": "besselj1",
+ "pkg_desc": "compute the Bessel function of the first kind of order one for a double-precision floating-point number",
+ "desc": "computes the Bessel function of the first kind of order one for a double-precision floating-point number",
+ "short_desc": "Bessel function of the first kind of order one",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -100,
+ 100
+ ]
+ },
+ "example_values": [
+ 0.2,
+ -0.87,
+ 4.1,
+ -6.3,
+ 12.7,
+ -2.25,
+ 50.9,
+ -99.4,
+ 8.2,
+ -3.6,
+ 0,
+ 31.4,
+ -15.9,
+ 72.3,
+ -41.2,
+ 1.07,
+ -250.8,
+ 5.5,
+ -27.3,
+ 1000
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "evaluated Bessel function",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "bessel",
+ "j1"
+ ],
+ "extra_keywords": []
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely0/package.json b/lib/node_modules/@stdlib/math/base/special/bessely0/package.json
index 1ddd4b136175..d2a867384e57 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely0/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/bessely0/package.json
@@ -61,5 +61,77 @@
"bessel",
"y0",
"number"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "bessely0",
+ "alias": "bessely0",
+ "pkg_desc": "compute the Bessel function of the second kind of order zero for a double-precision floating-point number",
+ "desc": "computes the Bessel function of the second kind of order zero for a double-precision floating-point number",
+ "short_desc": "Bessel function of the second kind of order zero",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": 0,
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ 0.01,
+ 100
+ ]
+ },
+ "example_values": [
+ 73.4,
+ 0.11,
+ 5.07,
+ 120.8,
+ 0.63,
+ 44.2,
+ 2.9,
+ 89.5,
+ 0.02,
+ 15.3,
+ 33.7,
+ 0.95,
+ 7.8,
+ 58.1,
+ 101.3,
+ 0.27,
+ 24.6,
+ 12.9,
+ 66.4,
+ 150.2
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "evaluated Bessel function",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "bessel",
+ "y0"
+ ],
+ "extra_keywords": []
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely1/package.json b/lib/node_modules/@stdlib/math/base/special/bessely1/package.json
index dfc66a99678c..e53fe3ab0d57 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely1/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/bessely1/package.json
@@ -61,5 +61,77 @@
"bessel",
"y1",
"number"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "bessely1",
+ "alias": "bessely1",
+ "pkg_desc": "compute the Bessel function of the second kind of order one for a double-precision floating-point number",
+ "desc": "computes the Bessel function of the second kind of order one for a double-precision floating-point number",
+ "short_desc": "Bessel function of the second kind of order one",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": 0,
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ 0.01,
+ 100
+ ]
+ },
+ "example_values": [
+ 73.2,
+ 0.03,
+ 5.41,
+ 121.7,
+ 0.67,
+ 44.9,
+ 2.85,
+ 89.1,
+ 0.12,
+ 15.8,
+ 33.05,
+ 0.98,
+ 7.43,
+ 58.6,
+ 101.9,
+ 0.29,
+ 24.1,
+ 12.2,
+ 66.9,
+ 140.3
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "evaluated Bessel function",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "bessel",
+ "y1"
+ ],
+ "extra_keywords": []
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/binet/package.json b/lib/node_modules/@stdlib/math/base/special/binet/package.json
index d8392a16d0cf..c6083462fb82 100644
--- a/lib/node_modules/@stdlib/math/base/special/binet/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/binet/package.json
@@ -64,5 +64,80 @@
"fib",
"number",
"reals"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "binet",
+ "alias": "binet",
+ "pkg_desc": "evaluate Binet's formula extended to real numbers for a double-precision floating-point number",
+ "desc": "evaluates Binet's formula extended to real numbers for a double-precision floating-point number",
+ "short_desc": "Binet's formula",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -50,
+ 50
+ ]
+ },
+ "example_values": [
+ 250.8,
+ -41.2,
+ 0.37,
+ -120.5,
+ 73.1,
+ -7.6,
+ 12.3,
+ -0.95,
+ 19.8,
+ -25.7,
+ 5.5,
+ -3.9,
+ 34.6,
+ -88.4,
+ 1.7,
+ 0,
+ 47.8,
+ -15.4,
+ 102.6,
+ -10.3
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "real-valued result",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "binet",
+ "fibonacci",
+ "fib",
+ "number",
+ "reals"
+ ],
+ "extra_keywords": []
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/ceil2/package.json b/lib/node_modules/@stdlib/math/base/special/ceil2/package.json
index ab8a6ceda0e7..9ca492cff594 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceil2/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/ceil2/package.json
@@ -64,5 +64,84 @@
"prevpow2",
"nearest",
"number"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "ceil2",
+ "alias": "ceil2",
+ "pkg_desc": "round a double-precision floating-point number to the nearest power of two toward positive infinity",
+ "desc": "rounds a double-precision floating-point number to the nearest power of two toward positive infinity",
+ "short_desc": "",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -100,
+ 100
+ ]
+ },
+ "example_values": [
+ 47.95,
+ -311.8,
+ 0.07,
+ 123.4,
+ -0.02,
+ 2.49,
+ 2049.9,
+ -73.45,
+ 6.88,
+ 1.17,
+ 79.6,
+ -5.06,
+ 511.2,
+ 0,
+ 21.3,
+ -0.83,
+ 4.63,
+ 9.01,
+ 0.28,
+ 13.57
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "rounded value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "double",
+ "dtype": "float64"
+ }
+ },
+ "keywords": [
+ "ceil",
+ "ceil2",
+ "round",
+ "nextpow2",
+ "prevpow2",
+ "nearest",
+ "number"
+ ],
+ "extra_keywords": [
+ "math.ceil"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/math/base/special/ceilf/package.json b/lib/node_modules/@stdlib/math/base/special/ceilf/package.json
index 148b58ae6e25..1871a58a5569 100644
--- a/lib/node_modules/@stdlib/math/base/special/ceilf/package.json
+++ b/lib/node_modules/@stdlib/math/base/special/ceilf/package.json
@@ -67,5 +67,83 @@
"float32",
"single-precision",
"flt"
- ]
+ ],
+ "__stdlib__": {
+ "scaffold": {
+ "$schema": "math/base@v1.0",
+ "base_alias": "ceil",
+ "alias": "ceilf",
+ "pkg_desc": "round a single-precision floating-point number toward positive infinity",
+ "desc": "rounds a single-precision floating-point number toward positive infinity",
+ "short_desc": "",
+ "parameters": [
+ {
+ "name": "x",
+ "desc": "input value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ },
+ "domain": [
+ {
+ "min": "-infinity",
+ "max": "infinity"
+ }
+ ],
+ "rand": {
+ "prng": "random/base/uniform",
+ "parameters": [
+ -50,
+ 50
+ ]
+ },
+ "example_values": [
+ 11.11,
+ -0.01,
+ 31.6,
+ -7.2,
+ 0.49,
+ 49.99,
+ 2.3,
+ -13.7,
+ 0,
+ 7.01,
+ -0.9,
+ 19.7,
+ 3.99,
+ 0.02,
+ 42.05,
+ 1.01,
+ 23.4,
+ 5.6,
+ 15.2,
+ 9.9
+ ]
+ }
+ ],
+ "output_policy": "real_floating_point_and_generic",
+ "returns": {
+ "desc": "rounded value",
+ "type": {
+ "javascript": "number",
+ "jsdoc": "number",
+ "c": "float",
+ "dtype": "float32"
+ }
+ },
+ "keywords": [
+ "ceil",
+ "round",
+ "integer",
+ "nearest",
+ "ceiling",
+ "floor"
+ ],
+ "extra_keywords": [
+ "math.ceil"
+ ]
+ }
+ }
}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/README.md b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/README.md
new file mode 100644
index 000000000000..744dab1f7966
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/README.md
@@ -0,0 +1,243 @@
+
+
+# flattenShape
+
+> Flatten a shape to a specified depth.
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
+```
+
+#### flattenShape( shape, depth )
+
+Flattens a shape to a specified depth.
+
+```javascript
+var sh = flattenShape( [ 3, 2 ], 1 );
+// returns [ 6 ]
+```
+
+The function accepts the following parameters:
+
+- **shape**: array shape.
+- **depth**: maximum depth to flatten.
+
+#### flattenShape.assign( shape, depth, out )
+
+Flattens a shape to a specified depth and assigns results to a provided output array.
+
+```javascript
+var sh = [ 0 ];
+
+var out = flattenShape.assign( [ 3, 2 ], 1, sh );
+// returns [ 6 ]
+
+var bool = ( sh === out );
+// returns true
+```
+
+The function accepts the following parameters:
+
+- **shape**: array shape.
+- **depth**: maximum depth to flatten.
+- **out**: output array.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var zip = require( '@stdlib/array/base/zip' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
+
+var opts = {
+ 'dtype': 'int32'
+};
+var d1 = discreteUniform( 100, 1, 10, opts );
+var d2 = discreteUniform( d1.length, 1, 10, opts );
+var d3 = discreteUniform( d1.length, 1, 10, opts );
+var d4 = discreteUniform( d1.length, 1, 10, opts );
+
+var depths = discreteUniform( d1.length, 0, 3, opts );
+var shapes = zip( [ d1, d2, d3, d4 ] );
+
+logEachMap( 'shape: (%s). depth: %d. flattened: (%s).', shapes, depths, flattenShape );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+#include "stdlib/ndarray/base/flatten_shape.h"
+```
+
+#### stdlib_ndarray_flatten_shape( ndims, \*shape, depth, \*out )
+
+Flattens a shape to a specified depth.
+
+```c
+const int64_t ndims = 3;
+const int64_t shape[] = { 2, 3, 10 };
+int64_t out[ 1 ];
+
+stdlib_ndarray_flatten_shape( ndims, shape, 2, out );
+```
+
+The function accepts the following arguments:
+
+- **ndims**: `[in] int64_t` number of dimensions.
+- **shape**: `[in] int64_t*` array shape (dimensions).
+- **depth**: `[in] int64_t` maximum depth to flatten.
+- **out**: `[out] int64_t*` output array.
+
+```c
+int8_t stdlib_ndarray_flatten_shape( const int64_t ndims, const int64_t *shape, const int64_t depth, int64_t *out );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+#include "stdlib/ndarray/base/flatten_shape.h"
+#include
+#include
+
+int main( void ) {
+ const int64_t shape[] = { 2, 3, 4, 10 };
+ const int64_t ndims = 4;
+ const int64_t depth = 2;
+ int64_t out[ 2 ];
+
+ stdlib_ndarray_flatten_shape( ndims, shape, depth, out );
+
+ int i;
+ printf( "shape = ( " );
+ for ( i = 0; i < ndims-depth; i++ ) {
+ printf( "%"PRId64"", out[ i ] );
+ if ( i < ndims-depth-1 ) {
+ printf( ", " );
+ }
+ }
+ printf( " )\n" );
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/benchmark.js
new file mode 100644
index 000000000000..5d1190ae2557
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/benchmark.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var isArray = require( '@stdlib/assert/is-array' );
+var pkg = require( './../package.json' ).name;
+var flattenShape = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var shape;
+ var out;
+ var i;
+
+ shape = discreteUniform( 5, 1, 10, {
+ 'dtype': 'generic'
+ });
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ shape[ 0 ] += 1;
+ out = flattenShape( shape, 3 );
+ if ( out.length !== 2 ) {
+ b.fail( 'should have expected length' );
+ }
+ }
+ b.toc();
+ if ( !isArray( out ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+':assign', function benchmark( b ) {
+ var shape;
+ var out;
+ var i;
+
+ shape = discreteUniform( 5, 1, 10, {
+ 'dtype': 'generic'
+ });
+
+ out = [ 0, 0 ];
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ shape[ 0 ] += 1;
+ out = flattenShape.assign( shape, 3, out );
+ if ( out.length !== 2 ) {
+ b.fail( 'should have expected length' );
+ }
+ }
+ b.toc();
+ if ( !isArray( out ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/Makefile b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/Makefile
new file mode 100644
index 000000000000..5d7e79f50788
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+ QUIET := @
+else
+ QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+ OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+ CC := $(C_COMPILER)
+else
+ CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+ -std=c99 \
+ -O3 \
+ -Wall \
+ -pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+ fPIC ?=
+else
+ fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.out
+
+
+# RULES #
+
+#/
+# Compiles C source files.
+#
+# @param {string} SOURCE_FILES - list of C source files
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lpthread -lblas`)
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [C_COMPILER] - C compiler
+# @param {string} [CFLAGS] - C compiler flags
+# @param {(string|void)} [fPIC] - compiler flag indicating whether to generate position independent code
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} SOURCE_FILES - list of C source files
+# @param {(string|void)} INCLUDE - list of includes (e.g., `-I /foo/bar -I /beep/boop`)
+# @param {(string|void)} LIBRARIES - list of libraries (e.g., `-lpthread -lblas`)
+# @param {(string|void)} LIBPATH - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} CC - C compiler
+# @param {string} CFLAGS - C compiler flags
+# @param {(string|void)} fPIC - compiler flag indicating whether to generate position independent code
+#/
+$(c_targets): %.out: %.c
+ $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+ $(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+ $(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/benchmark.c
new file mode 100644
index 000000000000..c593d07592c7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/benchmark/c/benchmark.c
@@ -0,0 +1,140 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "stdlib/ndarray/base/flatten_shape.h"
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define NAME "flatten-shape"
+#define ITERATIONS 1000000
+#define REPEATS 3
+
+/**
+* Prints the TAP version.
+*/
+static void print_version( void ) {
+ printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total total number of tests
+* @param passing total number of passing tests
+*/
+static void print_summary( int total, int passing ) {
+ printf( "#\n" );
+ printf( "1..%d\n", total ); // TAP plan
+ printf( "# total %d\n", total );
+ printf( "# pass %d\n", passing );
+ printf( "#\n" );
+ printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param elapsed elapsed time in seconds
+*/
+static void print_results( double elapsed ) {
+ double rate = (double)ITERATIONS / elapsed;
+ printf( " ---\n" );
+ printf( " iterations: %d\n", ITERATIONS );
+ printf( " elapsed: %0.9f\n", elapsed );
+ printf( " rate: %0.9f\n", rate );
+ printf( " ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+static double tic( void ) {
+ struct timeval now;
+ gettimeofday( &now, NULL );
+ return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
+}
+
+/**
+* Generates a random number on the interval [0,1).
+*
+* @return random number
+*/
+static double rand_double( void ) {
+ int r = rand();
+ return (double)r / ( (double)RAND_MAX + 1.0 );
+}
+
+/**
+* Runs a benchmark.
+*
+* @return elapsed time in seconds
+*/
+static double benchmark( void ) {
+ double elapsed;
+ double t;
+ int i;
+
+ int64_t shape[] = { 10, 10, 10 };
+ int64_t ndims = 3;
+ int64_t out[ 1 ];
+
+ t = tic();
+ for ( i = 0; i < ITERATIONS; i++ ) {
+ shape[ 0 ] += 1;
+ stdlib_ndarray_flatten_shape( ndims, shape, 2, out );
+ if ( out[ 0 ] < 0 ) {
+ printf( "unexpected result\n" );
+ break;
+ }
+ }
+ elapsed = tic() - t;
+ if ( out[ 0 ] < 0 ) {
+ printf( "unexpected result\n" );
+ }
+ return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+ double elapsed;
+ int count;
+ int i;
+
+ count = 0;
+
+ // Use the current time to seed the random number generator:
+ srand( time( NULL ) );
+
+ print_version();
+ for ( i = 0; i < REPEATS; i++ ) {
+ count += 1;
+ printf( "# c::native::%s\n", NAME );
+ elapsed = benchmark();
+ print_results( elapsed );
+ printf( "ok %d benchmark finished\n", count );
+ }
+ print_summary( count, count );
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/repl.txt
new file mode 100644
index 000000000000..9102ed75f20d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/repl.txt
@@ -0,0 +1,56 @@
+
+{{alias}}( shape, depth )
+ Flattens a shape to a specified depth.
+
+ Parameters
+ ----------
+ shape: ArrayLike
+ Array shape.
+
+ depth: integer
+ Maximum depth to flatten.
+
+ Returns
+ -------
+ out: Array
+ Flattened shape.
+
+ Examples
+ --------
+ > var sh = [ 3, 2 ];
+ > var out = {{alias}}( sh, 1 )
+ [ 6 ]
+
+
+{{alias}}.assign( shape, depth, out )
+ Flattens a shape to a specified depth and assigns results to a provided
+ output array.
+
+ Parameters
+ ----------
+ shape: ArrayLike
+ Array shape.
+
+ depth: integer
+ Maximum depth to flatten.
+
+ out: Array|TypedArray|Object
+ Output array.
+
+ Returns
+ -------
+ out: Array|TypedArray|Object
+ Output array.
+
+ Examples
+ --------
+ > var sh = [ 2, 1, 10 ];
+ > var out = [ 0 ];
+ > var s = {{alias}}.assign( sh, 2, out )
+ [ 20 ]
+ > var bool = ( s === out )
+ true
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/index.d.ts
new file mode 100644
index 000000000000..84ab457343dc
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/index.d.ts
@@ -0,0 +1,56 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { Collection } from '@stdlib/types/array';
+
+/**
+* Flattens a shape to a specified depth.
+*
+* @param shape - array shape
+* @param depth - maximum depth to flatten
+* @returns flattened shape
+*
+* @example
+* var sh = flattenShape( [ 3, 2 ], 1 );
+* // returns [ 6 ]
+*
+* sh = flattenShape( [ 3, 2, 1 ], 1 );
+* // returns [ 6, 1 ]
+*
+* sh = flattenShape( [ 3 ], 0 );
+* // returns [ 3 ]
+*
+* sh = flattenShape( [ 3, 2 ], 0 );
+* // returns [ 3, 2 ]
+*
+* sh = flattenShape( [ 3 ], 1 );
+* // returns [ 3 ]
+*
+* sh = flattenShape( [], 1 );
+* // returns []
+*/
+declare function flattenShape( shape: Collection, depth: number ): Array;
+
+
+// EXPORTS //
+
+export = flattenShape;
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/test.ts
new file mode 100644
index 000000000000..019010a42369
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/docs/types/test.ts
@@ -0,0 +1,58 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import flattenShape = require( './index' );
+
+
+// TESTS //
+
+// The function returns an array of numbers...
+{
+ flattenShape( [ 3, 2, 1 ], 1 ); // $ExpectType number[]
+}
+
+// The compiler throws an error if the function is provided a first argument that is not an array-like object containing numbers...
+{
+ flattenShape( true, 1 ); // $ExpectError
+ flattenShape( false, 1 ); // $ExpectError
+ flattenShape( null, 1 ); // $ExpectError
+ flattenShape( undefined, 1 ); // $ExpectError
+ flattenShape( '5', 1 ); // $ExpectError
+ flattenShape( [ '1', '2' ], 1 ); // $ExpectError
+ flattenShape( {}, 1 ); // $ExpectError
+ flattenShape( ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument that is not a number...
+{
+ flattenShape( [ 2, 3 ], true ); // $ExpectError
+ flattenShape( [ 2, 3 ], false ); // $ExpectError
+ flattenShape( [ 2, 3 ], null ); // $ExpectError
+ flattenShape( [ 2, 3 ], undefined ); // $ExpectError
+ flattenShape( [ 2, 3 ], '5' ); // $ExpectError
+ flattenShape( [ 2, 3 ], [ '1', '2' ] ); // $ExpectError
+ flattenShape( [ 2, 3 ], {} ); // $ExpectError
+ flattenShape( [ 2, 3 ], ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ flattenShape(); // $ExpectError
+ flattenShape( [ 3, 2 ] ); // $ExpectError
+ flattenShape( [ 3, 2 ], 1, 0 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/Makefile b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/Makefile
new file mode 100644
index 000000000000..25ced822f96a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+ QUIET := @
+else
+ QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+ OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+ CC := $(C_COMPILER)
+else
+ CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+ -std=c99 \
+ -O3 \
+ -Wall \
+ -pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+ fPIC ?=
+else
+ fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+ $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+ $(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+ $(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/example.c b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/example.c
new file mode 100644
index 000000000000..fa8da6b81979
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/c/example.c
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "stdlib/ndarray/base/flatten_shape.h"
+#include
+#include
+
+int main( void ) {
+ const int64_t shape[] = { 2, 3, 4, 10 };
+ const int64_t ndims = 4;
+ const int64_t depth = 2;
+ int64_t out[ 2 ];
+
+ stdlib_ndarray_flatten_shape( ndims, shape, depth, out );
+
+ int i;
+ printf( "shape = ( " );
+ for ( i = 0; i < ndims-depth; i++ ) {
+ printf( "%"PRId64"", out[ i ] );
+ if ( i < ndims-depth-1 ) {
+ printf( ", " );
+ }
+ }
+ printf( " )\n" );
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/index.js
new file mode 100644
index 000000000000..2385fdef4b4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/examples/index.js
@@ -0,0 +1,37 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var zip = require( '@stdlib/array/base/zip' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var flattenShape = require( './../lib' );
+
+var opts = {
+ 'dtype': 'int32'
+};
+var d1 = discreteUniform( 100, 1, 10, opts );
+var d2 = discreteUniform( d1.length, 1, 10, opts );
+var d3 = discreteUniform( d1.length, 1, 10, opts );
+var d4 = discreteUniform( d1.length, 1, 10, opts );
+
+var depths = discreteUniform( d1.length, 0, 3, opts );
+var shapes = zip( [ d1, d2, d3, d4 ] );
+
+logEachMap( 'shape: (%s). depth: %d. flattened: (%s).', shapes, depths, flattenShape );
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/include/stdlib/ndarray/base/flatten_shape.h b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/include/stdlib/ndarray/base/flatten_shape.h
new file mode 100644
index 000000000000..0b08ac9983fb
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/include/stdlib/ndarray/base/flatten_shape.h
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef STDLIB_NDARRAY_BASE_FLATTEN_SHAPE_H
+#define STDLIB_NDARRAY_BASE_FLATTEN_SHAPE_H
+
+#include
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Flattens a shape to a specified depth.
+*/
+int8_t stdlib_ndarray_flatten_shape( const int64_t ndims, const int64_t *shape, const int64_t depth, int64_t *out );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_NDARRAY_BASE_FLATTEN_SHAPE_H
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/assign.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/assign.js
new file mode 100644
index 000000000000..a64e5c582fc5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/assign.js
@@ -0,0 +1,74 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var min = require( '@stdlib/math/base/special/fast/min' );
+
+
+// MAIN //
+
+/**
+* Flattens a shape to a specified depth and assigns results to a provided output array.
+*
+* @param {NonNegativeIntegerArray} shape - array shape
+* @param {NonNegativeInteger} depth - maximum depth to flatten
+* @param {(Array|TypedArray|Object)} out - output object
+* @returns {(Array|TypedArray|Object)} array shape
+*
+* @example
+* var sh = [ 0, 0 ];
+*
+* var out = flattenShape( [ 3, 2 ], 1, sh );
+* // returns [ 6 ]
+*
+* var bool = ( out === sh );
+* // returns true
+*/
+function flattenShape( shape, depth, out ) {
+ var ndims;
+ var d;
+ var s;
+ var i;
+ var j;
+
+ ndims = shape.length;
+ d = min( ndims-1, depth );
+ s = 1;
+ j = 0;
+ for ( i = 0; i < ndims; i++ ) { // e.g., shape=[2,3,4,5], depth=2 => shape=[24,5]
+ if ( i <= d ) {
+ s *= shape[ i ];
+ if ( i === d ) {
+ out[ j ] = s;
+ j += 1;
+ }
+ } else {
+ out[ j ] = shape[ i ];
+ j += 1;
+ }
+ }
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = flattenShape;
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/index.js
new file mode 100644
index 000000000000..48e6205cfffa
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/index.js
@@ -0,0 +1,49 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Flatten a shape to a specified depth.
+*
+* @module @stdlib/ndarray/base/flatten-shape
+*
+* @example
+* var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
+*
+* var sh = flattenShape( [ 3, 2 ], 1 );
+* // returns [ 6 ]
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var assign = require( './assign.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'assign', assign );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "assign": "main.assign" }
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/main.js
new file mode 100644
index 000000000000..994c0e40ffb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/lib/main.js
@@ -0,0 +1,67 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var min = require( '@stdlib/math/base/special/fast/min' );
+var max = require( '@stdlib/math/base/special/fast/max' );
+var zeros = require( '@stdlib/array/base/zeros' );
+var assign = require( './assign.js' );
+
+
+// MAIN //
+
+/**
+* Flattens a shape to a specified depth.
+*
+* @param {NonNegativeIntegerArray} shape - array shape
+* @param {NonNegativeInteger} depth - maximum depth to flatten
+* @returns {NonNegativeIntegerArray} flattened shape
+*
+* @example
+* var sh = flattenShape( [ 3, 2 ], 1 );
+* // returns [ 6 ]
+*
+* sh = flattenShape( [ 3, 2, 1 ], 1 );
+* // returns [ 6, 1 ]
+*
+* sh = flattenShape( [ 3 ], 0 );
+* // returns [ 3 ]
+*
+* sh = flattenShape( [ 3, 2 ], 0 );
+* // returns [ 3, 2 ]
+*
+* sh = flattenShape( [ 3 ], 1 );
+* // returns [ 3 ]
+*
+* sh = flattenShape( [], 1 );
+* // returns []
+*/
+function flattenShape( shape, depth ) {
+ var ndims = shape.length;
+ var out = zeros( ndims-max( min( ndims-1, depth ), 0 ) );
+ assign( shape, depth, out );
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = flattenShape;
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/manifest.json b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/manifest.json
new file mode 100644
index 000000000000..04e61e361caa
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/manifest.json
@@ -0,0 +1,38 @@
+{
+ "options": {},
+ "fields": [
+ {
+ "field": "src",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "include",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "libraries",
+ "resolve": false,
+ "relative": false
+ },
+ {
+ "field": "libpath",
+ "resolve": true,
+ "relative": false
+ }
+ ],
+ "confs": [
+ {
+ "src": [
+ "./src/main.c"
+ ],
+ "include": [
+ "./include"
+ ],
+ "libraries": [],
+ "libpath": [],
+ "dependencies": []
+ }
+ ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/package.json b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/package.json
new file mode 100644
index 000000000000..cd879a825ba0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/package.json
@@ -0,0 +1,70 @@
+{
+ "name": "@stdlib/ndarray/base/flatten-shape",
+ "version": "0.0.0",
+ "description": "Flatten a shape to a specified depth.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "include": "./include",
+ "lib": "./lib",
+ "src": "./src",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "stdtypes",
+ "types",
+ "base",
+ "ndarray",
+ "shape",
+ "flatten",
+ "reshape",
+ "multidimensional",
+ "array",
+ "utilities",
+ "utility",
+ "utils",
+ "util"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/src/main.c b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/src/main.c
new file mode 100644
index 000000000000..0a53c6eaa40f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/src/main.c
@@ -0,0 +1,65 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "stdlib/ndarray/base/flatten_shape.h"
+#include
+
+/**
+* Flattens a shape to a specified depth.
+*
+* @param ndims number of dimensions
+* @param shape array shape (dimensions)
+* @param depth maximum depth
+* @param out output shape
+* @return status code
+*
+* @example
+* #include "stdlib/ndarray/base/flatten_shape.h"
+*
+* const int64_t ndims = 3;
+* const int64_t shape[] = { 2, 3, 10 };
+* int64_t out[ 1 ];
+*
+* stdlib_ndarray_flatten_shape( ndims, shape, 2, out );
+*/
+int8_t stdlib_ndarray_flatten_shape( const int64_t ndims, const int64_t *shape, const int64_t depth, int64_t *out ) {
+ int64_t d;
+ int64_t s;
+ int64_t i;
+ int64_t j;
+
+ d = ndims - 1;
+ if ( depth < d ) {
+ d = depth;
+ }
+ s = 1;
+ j = 0;
+ for ( i = 0; i < ndims; i++ ) { // e.g., shape=[2,3,4,5], depth=2 => shape=[24,5]
+ if ( i <= d ) {
+ s *= shape[ i ];
+ if ( i == d ) {
+ out[ j ] = s;
+ j += 1;
+ }
+ } else {
+ out[ j ] = shape[ i ];
+ j += 1;
+ }
+ }
+ return 0;
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/flatten-shape/test/test.js b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/test/test.js
new file mode 100644
index 000000000000..e9f441c71e70
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/flatten-shape/test/test.js
@@ -0,0 +1,141 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isArray = require( '@stdlib/assert/is-array' );
+var flattenShape = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof flattenShape, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function flattens a provided shape', function test( t ) {
+ var expected;
+ var actual;
+ var shape;
+
+ shape = [ 3, 2 ];
+ expected = [ 6 ];
+ actual = flattenShape( shape, 1 );
+
+ t.strictEqual( isArray( actual ), true, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected length' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 2, 10 ];
+ actual = flattenShape( shape, 1 );
+
+ t.strictEqual( isArray( actual ), true, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected length' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 2, 1, 10 ];
+ actual = flattenShape( shape, 0 );
+
+ t.strictEqual( isArray( actual ), true, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected length' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 20 ];
+ actual = flattenShape( shape, 2 );
+
+ t.strictEqual( isArray( actual ), true, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected length' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 20 ];
+ actual = flattenShape( shape, 10 );
+
+ t.strictEqual( isArray( actual ), true, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'attached to the main function is an `assign` method which supports flattening a provided shape and assigning results to an output array', function test( t ) {
+ var expected;
+ var actual;
+ var shape;
+ var out;
+
+ shape = [ 3, 2 ];
+ expected = [ 6 ];
+
+ out = [ 0 ];
+ actual = flattenShape.assign( shape, 1, out );
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 2, 10 ];
+
+ out = [ 0, 0 ];
+ actual = flattenShape.assign( shape, 1, out );
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 20 ];
+
+ out = [ 0 ];
+ actual = flattenShape.assign( shape, 2, out );
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 2, 1, 10 ];
+
+ out = [ 0, 0, 0 ];
+ actual = flattenShape.assign( shape, 0, out );
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ shape = [ 2, 1, 10 ];
+ expected = [ 20 ];
+
+ out = [ 0 ];
+ actual = flattenShape.assign( shape, 10, out );
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ t.deepEqual( actual, expected, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/lib/index.js
index deda5aac2b75..83a8674fb865 100644
--- a/lib/node_modules/@stdlib/ndarray/base/lib/index.js
+++ b/lib/node_modules/@stdlib/ndarray/base/lib/index.js
@@ -445,6 +445,15 @@ setReadOnly( ns, 'flag', require( '@stdlib/ndarray/base/flag' ) );
*/
setReadOnly( ns, 'flags', require( '@stdlib/ndarray/base/flags' ) );
+/**
+* @name flattenShape
+* @memberof ns
+* @readonly
+* @type {Function}
+* @see {@link module:@stdlib/ndarray/base/flatten-shape}
+*/
+setReadOnly( ns, 'flattenShape', require( '@stdlib/ndarray/base/flatten-shape' ) );
+
/**
* @name fliplr
* @memberof ns
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/README.md b/lib/node_modules/@stdlib/ndarray/flatten/README.md
new file mode 100644
index 000000000000..156801cd8799
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/README.md
@@ -0,0 +1,175 @@
+
+
+# flatten
+
+> Return a flattened copy of an input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var flatten = require( '@stdlib/ndarray/flatten' );
+```
+
+#### flatten( x\[, options] )
+
+Returns a flattened copy of an input [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x );
+// returns
+
+var arr = ndarray2array( y );
+// returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+```
+
+The function accepts the following arguments:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor].
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **order**: order in which input [ndarray][@stdlib/ndarray/ctor] elements should be flattened. Must be one of the following:
+
+ - `'row-major'`: flatten elements in lexicographic order. For example, given a two-dimensional input [ndarray][@stdlib/ndarray/ctor] (i.e., a matrix), flattening in lexicographic order means flattening the input [ndarray][@stdlib/ndarray/ctor] row-by-row.
+ - `'column-major'`: flatten elements in colexicographic order. For example, given a two-dimensional input [ndarray][@stdlib/ndarray/ctor] (i.e., a matrix), flattening in colexicographic order means flattening the input [ndarray][@stdlib/ndarray/ctor] column-by-column.
+ - `'any'`: flatten according to the physical layout of the input [ndarray][@stdlib/ndarray/ctor] data in memory, regardless of the stated [order][@stdlib/ndarray/orders] of the input [ndarray][@stdlib/ndarray/ctor].
+ - `'same'`: flatten according to the stated [order][@stdlib/ndarray/orders] of the input [ndarray][@stdlib/ndarray/ctor].
+
+ Default: `'row-major'`.
+
+- **depth**: maximum number of input [ndarray][@stdlib/ndarray/ctor] dimensions to flatten.
+
+By default, the function flattens all dimensions of the input [ndarray][@stdlib/ndarray/ctor]. To flatten to a desired depth, specify the `depth` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x, {
+ 'depth': 1
+});
+// returns
+
+var arr = ndarray2array( y );
+// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+```
+
+By default, the input [ndarray][@stdlib/ndarray/ctor] is flattened in lexicographic order. To flatten elements in a different order, specify the `order` option.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+// returns
+
+var y = flatten( x, {
+ 'order': 'column-major'
+});
+// returns
+
+var arr = ndarray2array( y );
+// returns [ 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- The function **always** returns a copy of input [ndarray][@stdlib/ndarray/ctor] data, even when an input [ndarray][@stdlib/ndarray/ctor] already has the desired number of dimensions.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flatten = require( '@stdlib/ndarray/flatten' );
+
+var xbuf = discreteUniform( 12, -100, 100, {
+ 'dtype': 'generic'
+});
+
+var x = array( xbuf, {
+ 'shape': [ 2, 2, 3 ],
+ 'dtype': 'generic'
+});
+console.log( ndarray2array( x ) );
+
+var y = flatten( x );
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/orders]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/orders
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/flatten/benchmark/benchmark.js
new file mode 100644
index 000000000000..6c9f713addc7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/benchmark/benchmark.js
@@ -0,0 +1,310 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var zeros = require( '@stdlib/ndarray/base/zeros' );
+var pkg = require( './../package.json' ).name;
+var flatten = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg+'::2d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 10, 10 ], 'row-major' ),
+ zeros( 'float32', [ 10, 10 ], 'row-major' ),
+ zeros( 'int32', [ 10, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 10, 10 ], 'row-major' ),
+ zeros( 'generic', [ 10, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 1,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::2d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 10, 10 ], 'row-major' ),
+ zeros( 'float32', [ 10, 10 ], 'row-major' ),
+ zeros( 'int32', [ 10, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 10, 10 ], 'row-major' ),
+ zeros( 'generic', [ 10, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 1,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::3d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 2,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::3d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 10 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 10 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 2,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::4d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 3,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::4d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 3,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::5d:row-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 4,
+ 'order': 'row-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::5d:column-major', function benchmark( b ) {
+ var values;
+ var opts;
+ var y;
+ var i;
+ var j;
+
+ values = [
+ zeros( 'float64', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'float32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'int32', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'complex128', [ 2, 5, 2, 5, 1 ], 'row-major' ),
+ zeros( 'generic', [ 2, 5, 2, 5, 1 ], 'row-major' )
+ ];
+ opts = {
+ 'depth': 4,
+ 'order': 'column-major'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ j = i % values.length;
+ y = flatten( values[ j ], opts );
+ if ( typeof y !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( !isndarrayLike( y ) ) {
+ b.fail( 'should return an ndarray' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/flatten/docs/repl.txt
new file mode 100644
index 000000000000..4e2e4208667e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/docs/repl.txt
@@ -0,0 +1,45 @@
+
+{{alias}}( x[, options] )
+ Returns a flattened copy of an input ndarray.
+
+ The function always returns a copy of input ndarray data, even when an input
+ ndarray already has the desired number of dimensions.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input ndarray.
+
+ options: Object (optional)
+ Function options.
+
+ options.depth: integer (optional)
+ Maximum number of dimensions to flatten. By default, the function
+ flattens all input ndarray dimensions.
+
+ options.order: string (optional)
+ Order in which input ndarray elements should be flattened. The following
+ orders are supported:
+
+ - row-major: flatten in lexicographic order.
+ - column-major: flatten in colexicographic order.
+ - same: flatten according to the stated order of the input ndarray.
+ - any: flatten according to physical layout of the input ndarray data in
+ memory, regardless of the stated order of the input ndarray.
+
+ Default: 'row-major'.
+
+ Returns
+ -------
+ out: ndarray
+ Output ndarray.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+ > var y = {{alias}}( x );
+ > var arr = {{alias:@stdlib/ndarray/to-array}}( y )
+ [ 1.0, 2.0, 3.0, 4.0 ]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/flatten/docs/types/index.d.ts
new file mode 100644
index 000000000000..c7d0484a7b1d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/docs/types/index.d.ts
@@ -0,0 +1,86 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { ndarray, Order } from '@stdlib/types/ndarray';
+
+/**
+* Interface defining function options.
+*/
+interface Options {
+ /**
+ * Maximum number of dimensions to flatten.
+ *
+ * ## Notes
+ *
+ * - By default, the function flattens all input ndarray dimensions.
+ */
+ depth?: number;
+
+ /**
+ * Order in which input ndarray elements should be flattened.
+ *
+ * ## Notes
+ *
+ * - The following orders are supported:
+ *
+ * - **row-major**: flatten in lexicographic order.
+ * - **column-major**: flatten in colexicographic order.
+ * - **same**: flatten according to the stated order of the input ndarray.
+ * - **any**: flatten according to the physical layout of the input ndarray data in memory, regardless of the stated order of the input ndarray.
+ *
+ * - Default: 'row-major'.
+ */
+ order?: Order | 'same' | 'any';
+}
+
+/**
+* Returns a flattened copy of an input ndarray.
+*
+* ## Notes
+*
+* - The function **always** returns a copy of input ndarray data, even when an input ndarray already has the desired number of dimensions.
+*
+* @param x - input ndarray
+* @param options - function options
+* @param options.depth - maximum number of dimensions to flatten
+* @param options.order - order in which input ndarray elements should be flattened
+* @returns output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );;
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+*/
+declare function flatten( x: T, options?: Options ): T;
+
+
+// EXPORTS //
+
+export = flatten;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/flatten/docs/types/test.ts
new file mode 100644
index 000000000000..bc9d1cf920bc
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/docs/types/test.ts
@@ -0,0 +1,137 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import zeros = require( '@stdlib/ndarray/base/zeros' );
+import flatten = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ) ); // $ExpectType float64ndarray
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ) ); // $ExpectType complex128ndarray
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ) ); // $ExpectType genericndarray
+
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), {} ); // $ExpectType float64ndarray
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), {} ); // $ExpectType complex128ndarray
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), {} ); // $ExpectType genericndarray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray-like object...
+{
+ flatten( '5' ); // $ExpectError
+ flatten( 5 ); // $ExpectError
+ flatten( true ); // $ExpectError
+ flatten( false ); // $ExpectError
+ flatten( null ); // $ExpectError
+ flatten( undefined ); // $ExpectError
+ flatten( {} ); // $ExpectError
+ flatten( [ 1 ] ); // $ExpectError
+ flatten( ( x: number ): number => x ); // $ExpectError
+
+ flatten( '5', {} ); // $ExpectError
+ flatten( 5, {} ); // $ExpectError
+ flatten( true, {} ); // $ExpectError
+ flatten( false, {} ); // $ExpectError
+ flatten( null, {} ); // $ExpectError
+ flatten( undefined, {} ); // $ExpectError
+ flatten( {}, {} ); // $ExpectError
+ flatten( [ 1 ], {} ); // $ExpectError
+ flatten( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), '5' ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), true ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), false ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), null ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), [ 1 ] ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), ( x: number ): number => x ); // $ExpectError
+
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), '5' ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), true ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), false ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), null ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), [ 1 ] ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), ( x: number ): number => x ); // $ExpectError
+
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), '5' ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), true ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), false ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), null ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), [ 1 ] ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument with invalid `depth` option...
+{
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': '5' } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': true } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': false } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': null } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'depth': ( x: number ): number => x } ); // $ExpectError
+
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': '5' } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': true } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': false } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': null } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'depth': ( x: number ): number => x } ); // $ExpectError
+
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': '5' } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': true } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': false } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': null } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'depth': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument with invalid `order` option...
+{
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': '5' } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': true } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': false } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': null } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'float64', [ 2, 2, 2 ], 'row-major' ), { 'order': ( x: number ): number => x } ); // $ExpectError
+
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': '5' } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': true } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': false } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': null } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'complex128', [ 2, 2, 2 ], 'row-major' ), { 'order': ( x: number ): number => x } ); // $ExpectError
+
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': '5' } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': true } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': false } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': null } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': [ 1 ] } ); // $ExpectError
+ flatten( zeros( 'generic', [ 2, 2, 2 ], 'row-major' ), { 'order': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = zeros( 'float64', [ 2, 2, 2 ], 'row-major' );
+
+ flatten(); // $ExpectError
+ flatten( x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/examples/index.js b/lib/node_modules/@stdlib/ndarray/flatten/examples/index.js
new file mode 100644
index 000000000000..f3c5b9214327
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/examples/index.js
@@ -0,0 +1,37 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var array = require( '@stdlib/ndarray/array' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flatten = require( './../lib' );
+
+var xbuf = discreteUniform( 12, -100, 100, {
+ 'dtype': 'generic'
+});
+
+var x = array( xbuf, {
+ 'shape': [ 2, 2, 3 ],
+ 'dtype': 'generic'
+});
+console.log( ndarray2array( x ) );
+
+var y = flatten( x );
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/lib/index.js b/lib/node_modules/@stdlib/ndarray/flatten/lib/index.js
new file mode 100644
index 000000000000..85584b794fd1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/lib/index.js
@@ -0,0 +1,50 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Return a flattened copy of an input ndarray.
+*
+* @module @stdlib/ndarray/flatten
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+* var flatten = require( '@stdlib/ndarray/flatten' );
+*
+* // Create an input ndarray:
+* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+* // return
+*
+* // Flatten the input ndarray:
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/lib/main.js b/lib/node_modules/@stdlib/ndarray/flatten/lib/main.js
new file mode 100644
index 000000000000..22ecfba4112d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/lib/main.js
@@ -0,0 +1,358 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var isPlainObject = require( '@stdlib/assert/is-plain-object' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isNonNegativeInteger = require( '@stdlib/assert/is-nonnegative-integer' );
+var isOrder = require( '@stdlib/ndarray/base/assert/is-order' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var getStrides = require( '@stdlib/ndarray/strides' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var getDType = require( '@stdlib/ndarray/base/dtype' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2order = require( '@stdlib/ndarray/base/strides2order' );
+var flattenShape = require( '@stdlib/ndarray/base/flatten-shape' );
+var assign = require( '@stdlib/ndarray/base/assign' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var format = require( '@stdlib/string/format' );
+
+
+// VARIABLES //
+
+var ROW_MAJOR = 'row-major';
+var COL_MAJOR = 'column-major';
+
+
+// MAIN //
+
+/**
+* Returns a flattened copy of an input ndarray.
+*
+* @param {ndarray} x - input ndarray
+* @param {Options} [options] - function options
+* @param {NonNegativeInteger} [options.depth] - maximum number of dimensions to flatten
+* @param {string} [options.order='row-major'] - order in which input ndarray elements should be flattened
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {TypeError} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ [ [ 1.0, 2.0 ] ], [ [ 3.0, 4.0 ] ], [ [ 5.0, 6.0 ] ] ] );
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+* 'shape': [ 2, 3 ],
+* 'order': 'column-major'
+* });
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 ]
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+* 'shape': [ 2, 3 ],
+* 'order': 'row-major'
+* });
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'column-major'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 4.0, 2.0, 5.0, 3.0, 6.0 ]
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+* 'shape': [ 2, 3 ],
+* 'order': 'column-major'
+* });
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'row-major'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 3.0, 5.0, 2.0, 4.0, 6.0 ]
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+* 'shape': [ 2, 3 ],
+* 'order': 'row-major'
+* });
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'same'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+* 'shape': [ 2, 3 ],
+* 'order': 'column-major'
+* });
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'same'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -6, -2 ], 10, 'row-major' );
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is column-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -6, -2 ], 10, 'column-major' );
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is column-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -6, -2 ], 10, 'column-major' );
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'same'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 3.0, 5.0, 2.0, 4.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is column-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -6, -2 ], 10, 'column-major' );
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'any'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is row-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -2, -4 ], 10, 'row-major' );
+* // return
+*
+* var y = flatten( x );
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 4.0, 2.0, 5.0, 3.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is row-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -2, -4 ], 10, 'row-major' );
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'same'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 4.0, 2.0, 5.0, 3.0, 1.0 ]
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var xbuf = [ 1.0, null, 2.0, null, 3.0, null, 4.0, null, 5.0, null, 6.0, null ];
+*
+* // Create an ndarray whose stated order is row-major, but which has been transposed:
+* var x = new ndarray( 'generic', xbuf, [ 2, 3 ], [ -2, -4 ], 10, 'row-major' );
+* // return
+*
+* var y = flatten( x, {
+* 'order': 'any'
+* });
+* // returns
+*
+* var arr = ndarray2array( y );
+* // returns [ 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ]
+*/
+function flatten( x, options ) {
+ var nargs;
+ var view;
+ var opts;
+ var xsh;
+ var st;
+ var o;
+ var y;
+
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ nargs = arguments.length;
+ xsh = getShape( x );
+
+ // Define default options:
+ opts = {
+ 'depth': xsh.length, // by default, flatten to a one-dimensional ndarray
+ 'order': ROW_MAJOR // by default, flatten in lexicographic order (i.e., trailing dimensions first; e.g., if `x` is a matrix, flatten row-by-row)
+ };
+
+ // Resolve function options...
+ if ( nargs === 2 ) {
+ if ( !isPlainObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ if ( hasOwnProp( options, 'depth' ) ) {
+ if ( !isNonNegativeInteger( options.depth ) ) {
+ throw new TypeError( format( 'invalid option. `%s` option must be a nonnegative integer. Option: `%s`.', options.depth ) );
+ }
+ opts.depth = options.depth;
+ }
+ if ( hasOwnProp( options, 'order' ) ) {
+ if ( options.order === 'any' ) {
+ // When 'any', we want to flatten according to the physical layout of the data in memory...
+ o = strides2order( getStrides( x ) );
+ if ( o === 1 ) {
+ // Data is currently arranged in row-major order:
+ opts.order = ROW_MAJOR;
+ } else if ( o === 2 ) {
+ // Data is currently arranged in column-major order:
+ opts.order = COL_MAJOR;
+ } else { // o === 0 || o === 3 (i.e., neither row- nor column-major || both row- and column-major
+ // When the data is either both row- and column-major (e.g., a one-dimensional ndarray) or neither row- nor column-major (e.g., unordered strides), fallback to flattening according to the stated order of the input ndarray:
+ opts.order = getOrder( x );
+ }
+ } else if ( options.order === 'same' ) {
+ // When 'same', we want to flatten according to the stated order of the input ndarray:
+ opts.order = getOrder( x );
+ } else if ( isOrder( options.order ) ) {
+ // When provided a specific order, flatten according to that order regardless of the order of the input ndarray:
+ opts.order = options.order;
+ } else {
+ throw new TypeError( format( 'invalid option. `%s` option must be a recognized order. Option: `%s`.', 'order', options.order ) );
+ }
+ }
+ }
+ // Create an output ndarray having contiguous memory:
+ y = emptyLike( x, {
+ 'shape': flattenShape( xsh, opts.depth ),
+ 'order': opts.order
+ });
+
+ // Create a view on top of output ndarray having the same shape as the input ndarray:
+ st = ( xsh.length > 0 ) ? shape2strides( xsh, opts.order ) : [ 0 ];
+ view = ndarray( getDType( y ), getData( y ), xsh, st, 0, opts.order );
+
+ // Copy elements to the output ndarray:
+ assign( [ x, view ] );
+
+ return y;
+}
+
+
+// EXPORTS //
+
+module.exports = flatten;
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/package.json b/lib/node_modules/@stdlib/ndarray/flatten/package.json
new file mode 100644
index 000000000000..317642b2cdde
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "@stdlib/ndarray/flatten",
+ "version": "0.0.0",
+ "description": "Return a flattened copy of an input ndarray.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "multidimensional",
+ "array",
+ "ndarray",
+ "tensor",
+ "matrix",
+ "flat",
+ "flatten",
+ "reshape",
+ "copy",
+ "transform"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/flatten/test/test.js b/lib/node_modules/@stdlib/ndarray/flatten/test/test.js
new file mode 100644
index 000000000000..02a079145248
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/flatten/test/test.js
@@ -0,0 +1,1360 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var Float64Array = require( '@stdlib/array/float64' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var flatten = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof flatten, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flatten( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flatten( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an options argument which is not an object', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ flatten( zeros( [ 2, 2, 2 ] ), value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an invalid `depth` option', function test( t ) {
+ var values;
+ var opts;
+ var i;
+
+ values = [
+ '5',
+ -5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ opts = {
+ 'depth': value
+ };
+ flatten( zeros( [ 2 ] ), opts );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an invalid `order` option', function test( t ) {
+ var values;
+ var opts;
+ var i;
+
+ values = [
+ '5',
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ opts = {
+ 'order': value
+ };
+ flatten( zeros( [ 2 ] ), opts );
+ };
+ }
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (row-major, non-contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 8, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 2.0, NaN, 3.0, NaN, 4.0, NaN, 5.0, NaN, 6.0, NaN, 7.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'by default, the function flattens all dimensions of a provided input ndarray in lexicographic order (column-major, non-contiguous)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = [ 2, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, NaN, 5.0, NaN, 3.0, NaN, 7.0, NaN, 2.0, NaN, 6.0, NaN, 4.0, NaN, 8.0, NaN ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the maximum number of dimensions to flatten (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'depth': 0
+ });
+ expected = [
+ [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ]
+ ],
+ [
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ],
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 2
+ });
+ expected = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the maximum number of dimensions to flatten (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'depth': 0
+ });
+ expected = [
+ [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ]
+ ],
+ [
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ],
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 2
+ });
+ expected = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in lexicographic order (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'row-major'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'row-major'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ],
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in lexicographic order (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'row-major'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'row-major'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ],
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in colexicographic order (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'column-major'
+ });
+ expected = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'column-major'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 5.0, 6.0 ],
+ [ 3.0, 4.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in colexicographic order (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'column-major'
+ });
+ expected = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'column-major'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 5.0, 6.0 ],
+ [ 3.0, 4.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in same order as the input ndarray (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'same'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ],
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray in same order as the input ndarray (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 1.0, 2.0 ],
+ * [ 3.0, 4.0 ]
+ * ],
+ * [
+ * [ 5.0, 6.0 ],
+ * [ 7.0, 8.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 1.0, 5.0, 3.0, 7.0, 2.0, 6.0, 4.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'same'
+ });
+ expected = [
+ [ 1.0, 2.0 ],
+ [ 5.0, 6.0 ],
+ [ 3.0, 4.0 ],
+ [ 7.0, 8.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray according to the physical layout of the input ndarray (row-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = [ -1, -2, -4 ]; // reversing and negating the strides simulates a flipped and reversed view
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 8.0, 4.0 ],
+ * [ 6.0, 2.0 ]
+ * ],
+ * [
+ * [ 7.0, 3.0 ],
+ * [ 5.0, 1.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'any'
+ });
+ expected = [
+ [ 8.0, 4.0 ],
+ [ 7.0, 3.0 ],
+ [ 6.0, 2.0 ],
+ [ 5.0, 1.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a provided input ndarray according to the physical layout of the input ndarray (column-major)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = [ -4, -2, -1 ]; // reversing and negating the strides simulates a flipped and reversed view
+ o = strides2offset( sh, st );
+
+ /*
+ * [
+ * [
+ * [ 8.0, 7.0 ],
+ * [ 6.0, 5.0 ]
+ * ],
+ * [
+ * [ 4.0, 3.0 ],
+ * [ 2.0, 1.0 ]
+ * ]
+ * ]
+ */
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ y = flatten( x, {
+ 'depth': 1,
+ 'order': 'any'
+ });
+ expected = [
+ [ 8.0, 7.0 ],
+ [ 6.0, 5.0 ],
+ [ 4.0, 3.0 ],
+ [ 2.0, 1.0 ]
+ ];
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.deepEqual( ndarray2array( y ), expected, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 4, 2 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a zero-dimensional input ndarray', function test( t ) {
+ var expected;
+ var xbuf;
+ var dt;
+ var x;
+ var y;
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'row-major'
+ });
+
+ y = flatten( x );
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'column-major'
+ });
+
+ y = flatten( x );
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a zero-dimensional input ndarray (order=same)', function test( t ) {
+ var expected;
+ var xbuf;
+ var dt;
+ var x;
+ var y;
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'row-major'
+ });
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'column-major'
+ });
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a zero-dimensional input ndarray (order=any)', function test( t ) {
+ var expected;
+ var xbuf;
+ var dt;
+ var x;
+ var y;
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'row-major'
+ });
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ x = scalar2ndarray( 3.0, {
+ 'dtype': dt,
+ 'order': 'column-major'
+ });
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 3.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a one-dimensional input ndarray', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x );
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a one-dimensional input ndarray (order=same)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'same'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports flattening a one-dimensional input ndarray (order=any)', function test( t ) {
+ var expected;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+ var y;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'row-major', 'returns expected value' );
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 8 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+ x = new ndarray( dt, xbuf, sh, st, o, ord );
+
+ y = flatten( x, {
+ 'order': 'any'
+ });
+ expected = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+ t.notEqual( y, x, 'returns expected value' );
+ t.notEqual( getData( y ), xbuf, 'returns expected value' );
+ t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
+ t.deepEqual( getShape( y ), [ 8 ], 'returns expected value' );
+ t.strictEqual( getDType( y ), dt, 'returns expected value' );
+ t.strictEqual( getOrder( y ), 'column-major', 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/repl/help/data/data.csv b/lib/node_modules/@stdlib/repl/help/data/data.csv
index 83eea6bbdbd3..bf1852f49bc9 100644
--- a/lib/node_modules/@stdlib/repl/help/data/data.csv
+++ b/lib/node_modules/@stdlib/repl/help/data/data.csv
@@ -1829,8 +1829,8 @@ base.strided.dnanmax,"\nbase.strided.dnanmax( N, x, strideX )\n Computes the
base.strided.dnanmax.ndarray,"\nbase.strided.dnanmax.ndarray( N, x, strideX, offsetX )\n Computes the maximum value of a double-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.dnanmax.ndarray( x.length, x, 1, 0 )\n 2.0\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.dnanmax.ndarray( 3, x, 2, 1 )\n 2.0\n\n See Also\n --------\n base.strided.dmax, base.strided.dnanmin, base.strided.nanmax, base.strided.snanmax"
base.strided.dnanmaxabs,"\nbase.strided.dnanmaxabs( N, x, strideX )\n Computes the maximum absolute value of a double-precision floating-point\n strided array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmaxabs( x.length, x, 1 )\n 2.0\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.dnanmaxabs( 3, x, 2 )\n 2.0\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dnanmaxabs( 3, x1, 2 )\n 2.0\n\n\nbase.strided.dnanmaxabs.ndarray( N, x, strideX, offsetX )\n Computes the maximum absolute value of a double-precision floating-point\n strided array, ignoring `NaN` values and using alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.dnanmaxabs.ndarray( x.length, x, 1, 0 )\n 2.0\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.dnanmaxabs.ndarray( 3, x, 2, 1 )\n 2.0\n\n See Also\n --------\n base.strided.dmaxabs, base.strided.dnanmax, base.strided.dnanminabs, base.strided.nanmaxabs, base.strided.snanmaxabs\n"
base.strided.dnanmaxabs.ndarray,"\nbase.strided.dnanmaxabs.ndarray( N, x, strideX, offsetX )\n Computes the maximum absolute value of a double-precision floating-point\n strided array, ignoring `NaN` values and using alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.dnanmaxabs.ndarray( x.length, x, 1, 0 )\n 2.0\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.dnanmaxabs.ndarray( 3, x, 2, 1 )\n 2.0\n\n See Also\n --------\n base.strided.dmaxabs, base.strided.dnanmax, base.strided.dnanminabs, base.strided.nanmaxabs, base.strided.snanmaxabs"
-base.strided.dnanmean,"\nbase.strided.dnanmean( N, x, strideX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and `stride` parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dnanmean( 4, x1,2 )\n ~-0.3333\n\n\nbase.strided.dnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.nanmean\n"
-base.strided.dnanmean.ndarray,"\nbase.strided.dnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.nanmean"
+base.strided.dnanmean,"\nbase.strided.dnanmean( N, x, strideX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and `stride` parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dnanmean( 4, x1,2 )\n ~-0.3333\n\n\nbase.strided.dnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.nanmean, base.strided.snanmean\n"
+base.strided.dnanmean.ndarray,"\nbase.strided.dnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.nanmean, base.strided.snanmean"
base.strided.dnanmeanors,"\nbase.strided.dnanmeanors( N, x, strideX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dnanmeanors( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanors, base.strided.dnanmean, base.strided.nanmeanors, base.strided.snanmeanors\n"
base.strided.dnanmeanors.ndarray,"\nbase.strided.dnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanors, base.strided.dnanmean, base.strided.nanmeanors, base.strided.snanmeanors"
base.strided.dnanmeanpn,"\nbase.strided.dnanmeanpn( N, x, strideX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmeanpn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmeanpn( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dnanmeanpn( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dnanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a double-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dnanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dnanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanpn, base.strided.dnanmean, base.strided.nanmeanpn, base.strided.snanmeanpn\n"
@@ -1935,8 +1935,8 @@ base.strided.dsmeanpw,"\nbase.strided.dsmeanpw( N, x, strideX )\n Computes th
base.strided.dsmeanpw.ndarray,"\nbase.strided.dsmeanpw.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using pairwise summation with extended accumulation and alternative\n indexing semantics and returning an extended precision result.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsmeanpw.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dsmeanpw.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanpw, base.strided.dsmean, base.strided.meanpw, base.strided.smeanpw"
base.strided.dsmeanwd,"\nbase.strided.dsmeanwd( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using Welford's algorithm with extended accumulation and returning an\n extended precision result.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed.\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsmeanwd( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dsmeanwd( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsmeanwd( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dsmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using Welford's algorithm with extended accumulation and alternative\n indexing semantics and returning an extended precision result.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Index increment.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dsmeanwd.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanwd, base.strided.dsmean, base.strided.dsnanmeanwd, base.strided.meanwd, base.strided.smeanwd\n"
base.strided.dsmeanwd.ndarray,"\nbase.strided.dsmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using Welford's algorithm with extended accumulation and alternative\n indexing semantics and returning an extended precision result.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Index increment.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dsmeanwd.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeanwd, base.strided.dsmean, base.strided.dsnanmeanwd, base.strided.meanwd, base.strided.smeanwd"
-base.strided.dsnanmean,"\nbase.strided.dsnanmean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values, using extended accumulation, and returning an\n extended precision result.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsnanmean( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dsnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsmean, base.strided.nanmean, base.strided.sdsnanmean\n"
-base.strided.dsnanmean.ndarray,"\nbase.strided.dsnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsmean, base.strided.nanmean, base.strided.sdsnanmean"
+base.strided.dsnanmean,"\nbase.strided.dsnanmean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values, using extended accumulation, and returning an\n extended precision result.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsnanmean( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dsnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsmean, base.strided.nanmean, base.strided.sdsnanmean, base.strided.snanmean\n"
+base.strided.dsnanmean.ndarray,"\nbase.strided.dsnanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsmean, base.strided.nanmean, base.strided.sdsnanmean, base.strided.snanmean"
base.strided.dsnanmeanors,"\nbase.strided.dsnanmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values, using ordinary recursive summation with\n extended accumulation, and returning an extended precision result.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsnanmeanors( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dsnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation with\n extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.dsmeanors, base.strided.dsnanmean, base.strided.nanmeanors, base.strided.sdsnanmean, base.strided.snanmeanors\n"
base.strided.dsnanmeanors.ndarray,"\nbase.strided.dsnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation with\n extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.dsmeanors, base.strided.dsnanmean, base.strided.nanmeanors, base.strided.sdsnanmean, base.strided.snanmeanors"
base.strided.dsnanmeanpn,"\nbase.strided.dsnanmeanpn( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values, using a two-pass error correction algorithm\n with extended accumulation, and returning an extended precision result.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmeanpn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmeanpn( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsnanmeanpn( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.dsnanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n with extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.dsnanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.dsnanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.dsmeanpn, base.strided.dsnanmean, base.strided.nanmeanpn, base.strided.sdsnanmean, base.strided.snanmeanpn\n"
@@ -1979,8 +1979,8 @@ base.strided.dstdevpn,"\nbase.strided.dstdevpn( N, correction, x, strideX )\n
base.strided.dstdevpn.ndarray,"\nbase.strided.dstdevpn.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a two-pass algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride Length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevpn.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevpn.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevpn, base.strided.dstdev, base.strided.dvariancepn, base.strided.sstdevpn, base.strided.stdevpn"
base.strided.dstdevtk,"\nbase.strided.dstdevtk( N, correction, x, strideX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass textbook algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevtk( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dstdevtk( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dstdevtk( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.dstdevtk.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass textbook algorithm and alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevtk.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevtk, base.strided.dstdev, base.strided.dvariancetk, base.strided.sstdevtk, base.strided.stdevtk\n"
base.strided.dstdevtk.ndarray,"\nbase.strided.dstdevtk.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass textbook algorithm and alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevtk.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevtk, base.strided.dstdev, base.strided.dvariancetk, base.strided.sstdevtk, base.strided.stdevtk"
-base.strided.dstdevwd,"\nbase.strided.dstdevwd( N, correction, x, strideX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dstdevwd( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dstdevwd( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.dstdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.dstdev, base.strided.dvariancewd, base.strided.stdevwd\n"
-base.strided.dstdevwd.ndarray,"\nbase.strided.dstdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.dstdev, base.strided.dvariancewd, base.strided.stdevwd"
+base.strided.dstdevwd,"\nbase.strided.dstdevwd( N, correction, x, strideX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dstdevwd( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dstdevwd( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.dstdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.dstdev, base.strided.dvariancewd, base.strided.sstdevwd, base.strided.stdevwd\n"
+base.strided.dstdevwd.ndarray,"\nbase.strided.dstdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.dstdev, base.strided.dvariancewd, base.strided.sstdevwd, base.strided.stdevwd"
base.strided.dstdevyc,"\nbase.strided.dstdevyc( N, correction, x, strideX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass algorithm proposed by Youngs and Cramer.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevyc( x.length, 1.0, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dstdevyc( 3, 1.0, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dstdevyc( 3, 1.0, x1, 2 )\n ~2.0817\n\n\nbase.strided.dstdevyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass algorithm proposed by Youngs and Cramer and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevyc.ndarray( x.length, 1.0, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevyc.ndarray( 3, 1.0, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevyc, base.strided.dstdev, base.strided.dvarianceyc, base.strided.sstdevyc, base.strided.stdevyc\n"
base.strided.dstdevyc.ndarray,"\nbase.strided.dstdevyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a double-precision floating-point strided\n array using a one-pass algorithm proposed by Youngs and Cramer and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dstdevyc.ndarray( x.length, 1.0, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dstdevyc.ndarray( 3, 1.0, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevyc, base.strided.dstdev, base.strided.dvarianceyc, base.strided.sstdevyc, base.strided.stdevyc"
base.strided.dsum,"\nbase.strided.dsum( N, x, strideX )\n Computes the sum of double-precision floating-point strided array elements.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsum( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float64Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.dsum( 3, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.dsum( 3, x1, 2 )\n -1.0\n\n\nbase.strided.dsum.ndarray( N, x, strideX, offsetX )\n Computes the sum of double-precision floating-point strided array elements\n using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float64Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.dsum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > x = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.dsum.ndarray( 3, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dasum, base.strided.dmean, base.strided.dnansum, base.strided.ssum, base.strided.gsum\n"
@@ -2156,8 +2156,8 @@ base.strided.nanmaxabs,"\nbase.strided.nanmaxabs( N, x, strideX )\n Computes
base.strided.nanmaxabs.ndarray,"\nbase.strided.nanmaxabs.ndarray( N, x, strideX, offsetX )\n Computes the maximum absolute value of a strided array, ignoring `NaN`\n values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmaxabs.ndarray( x.length, x, 1, 0 )\n 2.0\n\n // Using offset parameter:\n > var x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmaxabs.ndarray( 4, x, 2, 1 )\n 2.0\n\n See Also\n --------\n base.strided.dnanmaxabs, base.strided.maxabs, base.strided.nanmax, base.strided.nanminabs, base.strided.snanmaxabs"
base.strided.nanmaxBy,"\nbase.strided.nanmaxBy( N, x, strideX, clbk[, thisArg] )\n Computes the maximum value of strided array via a callback function,\n ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n If `N <= 0`, the function returns `NaN`.\n\n The callback function is provided four arguments:\n\n - value: array element.\n - aidx: array index.\n - sidx: strided index (offset + aidx*stride).\n - array: the input array.\n\n The callback function should return a numeric value.\n\n If the callback function returns `NaN`, the value is ignored.\n\n If the callback function does not return any value (or equivalently,\n explicitly returns `undefined`), the value is ignored.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray|Object\n Input array/collection. If provided an object, the object must be array-\n like (excluding strings and functions).\n\n strideX: integer\n Stride length.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > function accessor( v ) { return v * 2.0; };\n > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, -1.0, -3.0 ];\n > base.strided.nanmaxBy( x.length, x, 1, accessor )\n 8.0\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 3.0, -5.0, 4.0, -1.0, -3.0 ];\n > base.strided.nanmaxBy( 3, x, 2, accessor )\n 8.0\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.nanmaxBy( 3, x1, 2, accessor )\n -4.0\n\n\nbase.strided.nanmaxBy.ndarray( N, x, strideX, offsetX, clbk[, thisArg] )\n Computes the maximum value of a strided array via a callback function,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray|Object\n Input array/collection. If provided an object, the object must be array-\n like (excluding strings and functions).\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > function accessor( v ) { return v * 2.0; };\n > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, -1.0, -3.0 ];\n > base.strided.nanmaxBy.ndarray( x.length, x, 1, 0, accessor )\n 8.0\n\n // Using an index offset:\n > x = [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ];\n > base.strided.nanmaxBy.ndarray( 3, x, 2, 1, accessor )\n -4.0\n\n See Also\n --------\n base.strided.dnanmax, base.strided.maxBy, base.strided.nanmax, base.strided.nanminBy, base.strided.snanmax\n"
base.strided.nanmaxBy.ndarray,"\nbase.strided.nanmaxBy.ndarray( N, x, strideX, offsetX, clbk[, thisArg] )\n Computes the maximum value of a strided array via a callback function,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray|Object\n Input array/collection. If provided an object, the object must be array-\n like (excluding strings and functions).\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > function accessor( v ) { return v * 2.0; };\n > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, -1.0, -3.0 ];\n > base.strided.nanmaxBy.ndarray( x.length, x, 1, 0, accessor )\n 8.0\n\n // Using an index offset:\n > x = [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ];\n > base.strided.nanmaxBy.ndarray( 3, x, 2, 1, accessor )\n -4.0\n\n See Also\n --------\n base.strided.dnanmax, base.strided.maxBy, base.strided.nanmax, base.strided.nanminBy, base.strided.snanmax"
-base.strided.nanmean,"\nbase.strided.nanmean( N, x, strideX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ];\n > base.strided.nanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.nanmean( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.nanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.mean\n"
-base.strided.nanmean.ndarray,"\nbase.strided.nanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.mean"
+base.strided.nanmean,"\nbase.strided.nanmean( N, x, strideX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ];\n > base.strided.nanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.nanmean( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.nanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.mean, base.strided.snanmean\n"
+base.strided.nanmean.ndarray,"\nbase.strided.nanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.mean, base.strided.snanmean"
base.strided.nanmeanors,"\nbase.strided.nanmeanors( N, x, strideX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using ordinary recursive summation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ];\n > base.strided.nanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.nanmeanors( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.nanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using ordinary recursive summation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.meanors, base.strided.nanmean, base.strided.snanmeanors\n"
base.strided.nanmeanors.ndarray,"\nbase.strided.nanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using ordinary recursive summation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.meanors, base.strided.nanmean, base.strided.snanmeanors"
base.strided.nanmeanpn,"\nbase.strided.nanmeanpn( N, x, strideX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using a two-pass error correction algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmeanpn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ];\n > base.strided.nanmeanpn( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.nanmeanpn( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.nanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a strided array, ignoring `NaN` values and\n using a two-pass error correction algorithm and alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x =[ 1.0, -2.0, NaN, 2.0 ];\n > base.strided.nanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ];\n > base.strided.nanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.meanpn, base.strided.nanmean, base.strided.snanmeanpn\n"
@@ -2276,10 +2276,10 @@ base.strided.sdsdot,"\nbase.strided.sdsdot( N, scalar, x, strideX, y, strideY )\
base.strided.sdsdot.ndarray,"\nbase.strided.sdsdot.ndarray( N, scalar, x, strideX, offsetX, y, strideY, offsetY )\n Computes the dot product of two single-precision floating-point vectors\n using alternative indexing semantics and with extended accumulation.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameters support indexing based on a starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n scalar: number\n Scalar constant added to dot product.\n\n x: Float32Array\n First input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Float32Array\n Second input array.\n\n strideY: integer\n Index increment for `y`.\n\n offsetY: integer\n Starting index for `y`.\n\n Returns\n -------\n out: number\n The dot product.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float32Array( [ 4.0, 2.0, -3.0, 5.0, -1.0 ] );\n > var y = new Float32Array( [ 2.0, 6.0, -1.0, -4.0, 8.0 ] );\n > var out = base.strided.sdsdot.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 )\n -5.0\n\n // Strides:\n > x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > y = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n > out = base.strided.sdsdot.ndarray( 3, 0.0, x, 2, 0, y, 2, 0 )\n 9.0\n\n // Using offset indices:\n > x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > y = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > out = base.strided.sdsdot.ndarray( 3, 0.0, x, -2, x.length-1, y, 1, 3 )\n 128.0\n\n References\n ----------\n - Lawson, Charles L., Richard J. Hanson, Fred T. Krogh, and David Ronald\n Kincaid. 1979. \"Algorithm 539: Basic Linear Algebra Subprograms for Fortran\n Usage [F1].\" *ACM Transactions on Mathematical Software* 5 (3). New York,\n NY, USA: Association for Computing Machinery: 324–25.\n doi:10.1145/355841.355848.\n\n See Also\n --------\n base.strided.ddot, base.strided.dsdot, base.strided.sdot"
base.strided.sdsmean,"\nbase.strided.sdsmean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using extended accumulation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.sdsmean( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.sdsmean( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.sdsmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsnanmean, base.strided.smean\n"
base.strided.sdsmean.ndarray,"\nbase.strided.sdsmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsnanmean, base.strided.smean"
-base.strided.sdsmeanors,"\nbase.strided.sdsmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.sdsmeanors( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.sdsmeanors( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.sdsmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmean\n"
-base.strided.sdsmeanors.ndarray,"\nbase.strided.sdsmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmean"
-base.strided.sdsnanmean,"\nbase.strided.sdsnanmean( N, x, stride )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.sdsnanmean( N, x, stride )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.sdsnanmean( N, x1, stride )\n ~-0.3333\n\nbase.strided.sdsnanmean.ndarray( N, x, stride, offset )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.sdsnanmean.ndarray( N, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsnanmean, base.strided.nanmean, base.strided.sdsmean\n"
-base.strided.sdsnanmean.ndarray,"\nbase.strided.sdsnanmean.ndarray( N, x, stride, offset )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.sdsnanmean.ndarray( N, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsnanmean, base.strided.nanmean, base.strided.sdsmean"
+base.strided.sdsmeanors,"\nbase.strided.sdsmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.sdsmeanors( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.sdsmeanors( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.sdsmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmean, base.strided.sdsnanmeanors\n"
+base.strided.sdsmeanors.ndarray,"\nbase.strided.sdsmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using ordinary recursive summation with extended accumulation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.sdsmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.sdsmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmean, base.strided.sdsnanmeanors"
+base.strided.sdsnanmean,"\nbase.strided.sdsnanmean( N, x, stride )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.sdsnanmean( N, x, stride )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.sdsnanmean( N, x1, stride )\n ~-0.3333\n\nbase.strided.sdsnanmean.ndarray( N, x, stride, offset )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.sdsnanmean.ndarray( N, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsnanmean, base.strided.nanmean, base.strided.sdsmean, base.strided.snanmean\n"
+base.strided.sdsnanmean.ndarray,"\nbase.strided.sdsnanmean.ndarray( N, x, stride, offset )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.sdsnanmean.ndarray( N, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.dsnanmean, base.strided.nanmean, base.strided.sdsmean, base.strided.snanmean"
base.strided.sdsnanmeanors,"\nbase.strided.sdsnanmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation with\n extended accumulation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.sdsnanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.sdsnanmeanors( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.sdsnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation with\n extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.sdsnanmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmeanors, base.strided.sdsnanmean\n"
base.strided.sdsnanmeanors.ndarray,"\nbase.strided.sdsnanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation with\n extended accumulation and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.sdsnanmeanors.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.sdsmeanors, base.strided.sdsnanmean"
base.strided.sdsnansum,"\nbase.strided.sdsnansum( N, x, strideX )\n Computes the sum of single-precision floating-point strided array elements,\n ignore `NaN` values and using extended accumulation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnansum( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.sdsnansum( 4, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.sdsnansum( 4, x1, 2 )\n -1.0\n\n\nbase.strided.sdsnansum.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using extended accumulation and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.sdsnansum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.sdsnansum.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dsnansum, base.strided.dnansum, base.strided.gnansum, base.strided.sdssum, base.strided.snansum\n"
@@ -2308,8 +2308,8 @@ base.strided.smaxabssorted,"\nbase.strided.smaxabssorted( N, x, strideX )\n C
base.strided.smaxabssorted.ndarray,"\nbase.strided.smaxabssorted.ndarray( N, x, strideX, offsetX )\n Computes the maximum absolute value of a sorted single-precision floating-\n point strided array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Sorted input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ -1.0, -2.0, -3.0 ] );\n > base.strided.smaxabssorted.ndarray( x.length, x, 1, 0 )\n 3.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, 3.0 ] );\n > base.strided.smaxabssorted.ndarray( 3, x, 2, 1 )\n 3.0\n\n See Also\n --------\n base.strided.dmaxabssorted, base.strided.smaxabs, base.strided.smaxsorted"
base.strided.smaxsorted,"\nbase.strided.smaxsorted( N, x, strideX )\n Computes the maximum value of a sorted single-precision floating-point\n strided array.\n\n The input strided array must be sorted in either strictly ascending or\n descending order.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Sorted input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );\n > base.strided.smaxsorted( x.length, x, 1 )\n 3.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.smaxsorted( 3, x, 2 )\n 2.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, 3.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.smaxsorted( 3, x1, 2 )\n 3.0\n\n\nbase.strided.smaxsorted.ndarray( N, x, strideX, offsetX )\n Computes the maximum value of a sorted single-precision floating-point\n strided array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Sorted input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );\n > base.strided.smaxsorted.ndarray( x.length, x, 1, 0 )\n 3.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, 3.0 ] );\n > base.strided.smaxsorted.ndarray( 3, x, 2, 1 )\n 3.0\n\n See Also\n --------\n base.strided.dmaxsorted, base.strided.maxsorted, base.strided.smax, base.strided.sminsorted\n"
base.strided.smaxsorted.ndarray,"\nbase.strided.smaxsorted.ndarray( N, x, strideX, offsetX )\n Computes the maximum value of a sorted single-precision floating-point\n strided array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Sorted input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, 2.0, 3.0 ] );\n > base.strided.smaxsorted.ndarray( x.length, x, 1, 0 )\n 3.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, 3.0 ] );\n > base.strided.smaxsorted.ndarray( 3, x, 2, 1 )\n 3.0\n\n See Also\n --------\n base.strided.dmaxsorted, base.strided.maxsorted, base.strided.smax, base.strided.sminsorted"
-base.strided.smean,"\nbase.strided.smean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.smean( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.smean( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.smean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsmean\n"
-base.strided.smean.ndarray,"\nbase.strided.smean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsmean"
+base.strided.smean,"\nbase.strided.smean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.smean( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.smean( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.smean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsmean, base.strided.snanmean\n"
+base.strided.smean.ndarray,"\nbase.strided.smean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smean.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmean, base.strided.dsmean, base.strided.mean, base.strided.sdsmean, base.strided.snanmean"
base.strided.smeankbn,"\nbase.strided.smeankbn( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using an improved Kahan–Babuška algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smeankbn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.smeankbn( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.smeankbn( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.smeankbn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using an improved Kahan–Babuška algorithm and alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smeankbn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smeankbn.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeankbn, base.strided.meankbn, base.strided.smean\n"
base.strided.smeankbn.ndarray,"\nbase.strided.smeankbn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using an improved Kahan–Babuška algorithm and alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smeankbn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smeankbn.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeankbn, base.strided.meankbn, base.strided.smean"
base.strided.smeankbn2,"\nbase.strided.smeankbn2( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using a second-order iterative Kahan–Babuška algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smeankbn2( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.smeankbn2( 3, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.smeankbn2( 3, x1, 2 )\n ~-0.3333\n\n\nbase.strided.smeankbn2.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array using a second-order iterative Kahan–Babuška algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.smeankbn2.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.smeankbn2.ndarray( 3, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dmeankbn2, base.strided.meankbn2, base.strided.smean\n"
@@ -2374,12 +2374,12 @@ base.strided.snanmaxabs,"\nbase.strided.snanmaxabs( N, x, strideX )\n Compute
base.strided.snanmaxabs.ndarray,"\nbase.strided.snanmaxabs.ndarray( N, x, strideX, offsetX )\n Computes the maximum absolute value of a single-precision floating-point\n strided array, ignoring `NaN` values and using alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.snanmaxabs.ndarray( x.length, x, 1, 0 )\n 2.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.snanmaxabs.ndarray( 3, x, 2, 1 )\n 2.0\n\n See Also\n --------\n base.strided.dnanmaxabs, base.strided.nanmaxabs, base.strided.smaxabs, base.strided.snanmax, base.strided.snanminabs"
base.strided.snanmean,"\nbase.strided.snanmean( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmean( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.snanmean( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmean( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.smean, base.strided.nanmean\n"
base.strided.snanmean.ndarray,"\nbase.strided.snanmean.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmean.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmean.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmean, base.strided.smean, base.strided.nanmean"
-base.strided.snanmeanors,"\nbase.strided.snanmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.snanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanors( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.nanmeanors, base.strided.smeanors\n"
-base.strided.snanmeanors.ndarray,"\nbase.strided.snanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.nanmeanors, base.strided.smeanors"
-base.strided.snanmeanpn,"\nbase.strided.snanmeanpn( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanpn( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.nanmeanpn, base.strided.smeanpn\n"
-base.strided.snanmeanpn.ndarray,"\nbase.strided.snanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.nanmeanpn, base.strided.smeanpn"
-base.strided.snanmeanwd,"\nbase.strided.snanmeanwd( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanwd( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanwd, base.strided.nanmeanwd, base.strided.smeanwd"
-base.strided.snanmeanwd.ndarray,"\nbase.strided.snanmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanwd, base.strided.nanmeanwd, base.strided.smeanwd"
+base.strided.snanmeanors,"\nbase.strided.snanmeanors( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.snanmeanors( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanors( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.nanmeanors, base.strided.smeanors, base.strided.snanmean\n"
+base.strided.snanmeanors.ndarray,"\nbase.strided.snanmeanors.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using ordinary recursive summation and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanors.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanors.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanors, base.strided.nanmeanors, base.strided.smeanors, base.strided.snanmean"
+base.strided.snanmeanpn,"\nbase.strided.snanmeanpn( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanpn( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.nanmeanpn, base.strided.smeanpn, base.strided.snanmean\n"
+base.strided.snanmeanpn.ndarray,"\nbase.strided.snanmeanpn.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using a two-pass error correction algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanpn.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanpn.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanpn, base.strided.nanmeanpn, base.strided.smeanpn, base.strided.snanmean"
+base.strided.snanmeanwd,"\nbase.strided.snanmeanwd( N, x, strideX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd( x.length, x, 1 )\n ~0.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd( 4, x, 2 )\n ~0.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmeanwd( 4, x1, 2 )\n ~-0.3333\n\n\nbase.strided.snanmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanwd, base.strided.nanmeanwd, base.strided.smeanwd, base.strided.snanmean"
+base.strided.snanmeanwd.ndarray,"\nbase.strided.snanmeanwd.ndarray( N, x, strideX, offsetX )\n Computes the arithmetic mean of a single-precision floating-point strided\n array, ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: float\n The arithmetic mean.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmeanwd.ndarray( x.length, x, 1, 0 )\n ~0.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snanmeanwd.ndarray( 4, x, 2, 1 )\n ~-0.3333\n\n See Also\n --------\n base.strided.dnanmeanwd, base.strided.nanmeanwd, base.strided.smeanwd, base.strided.snanmean"
base.strided.snanmin,"\nbase.strided.snanmin( N, x, strideX )\n Computes the minimum value of a single-precision floating-point strided\n array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Minimum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanmin( x.length, x, 1 )\n -2.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.snanmin( 3, x, 2 )\n -2.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanmin( 3, x1, 2 )\n -2.0\n\n\nbase.strided.snanmin.ndarray( N, x, strideX, offsetX )\n Computes the minimum value of a single-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Minimum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.snanmin.ndarray( x.length, x, 1, 0 )\n -2.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.snanmin.ndarray( 3, x, 2, 1 )\n -2.0\n\n See Also\n --------\n base.strided.dnanmin, base.strided.nanmin, base.strided.smin, base.strided.snanmax\n"
base.strided.snanmin.ndarray,"\nbase.strided.snanmin.ndarray( N, x, strideX, offsetX )\n Computes the minimum value of a single-precision floating-point strided\n array, ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Minimum value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.snanmin.ndarray( x.length, x, 1, 0 )\n -2.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.snanmin.ndarray( 3, x, 2, 1 )\n -2.0\n\n See Also\n --------\n base.strided.dnanmin, base.strided.nanmin, base.strided.smin, base.strided.snanmax"
base.strided.snanminabs,"\nbase.strided.snanminabs( N, x, strideX )\n Computes the minimum absolute value of a single-precision floating-point\n strided array, ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Minimum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanminabs( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN ] );\n > base.strided.snanminabs( 3, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snanminabs( 3, x1, 2 )\n 1.0\n\n\nbase.strided.snanminabs.ndarray( N, x, strideX, offsetX )\n Computes the minimum absolute value of a single-precision floating-point\n strided array, ignoring `NaN` values and using alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Minimum absolute value.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0, NaN ] );\n > base.strided.snanminabs.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN ] );\n > base.strided.snanminabs.ndarray( 3, x, 2, 1 )\n 1.0\n\n See Also\n --------\n base.strided.dnanminabs, base.strided.nanminabs, base.strided.sminabs, base.strided.snanmaxabs, base.strided.snanmin\n"
@@ -2400,12 +2400,12 @@ base.strided.snanstdevpn,"\nbase.strided.snanstdevpn( N, correction, x, stride )
base.strided.snanstdevpn.ndarray,"\nbase.strided.snanstdevpn.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a two-pass algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevpn.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevpn.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevpn, base.strided.nanstdevpn, base.strided.snanstdev, base.strided.snanvariancepn, base.strided.sstdevpn"
base.strided.snanstdevtk,"\nbase.strided.snanstdevtk( N, correction, x, stride )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass textbook algorithm.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevtk( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.snanstdevtk( N, 1, x, stride )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.snanstdevtk( N, 1, x1, stride )\n ~2.0817\n\nbase.strided.snanstdevtk.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass textbook algorithm and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevtk.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevtk, base.strided.nanstdevtk, base.strided.snanstdev, base.strided.snanvariancetk, base.strided.sstdevtk\n"
base.strided.snanstdevtk.ndarray,"\nbase.strided.snanstdevtk.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass textbook algorithm and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevtk.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevtk, base.strided.nanstdevtk, base.strided.snanstdev, base.strided.snanvariancetk, base.strided.sstdevtk"
-base.strided.snanstdevwd,"\nbase.strided.snanstdevwd( N, correction, x, stride )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.snanstdevwd( N, 1, x, stride )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.snanstdevwd( N, 1, x1, stride )\n ~2.0817\n\nbase.strided.snanstdevwd.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevwd.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.nanstdevwd, base.strided.snanstdev, base.strided.snanvariancewd\n"
-base.strided.snanstdevwd.ndarray,"\nbase.strided.snanstdevwd.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevwd.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.nanstdevwd, base.strided.snanstdev, base.strided.snanvariancewd"
+base.strided.snanstdevwd,"\nbase.strided.snanstdevwd( N, correction, x, stride )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.snanstdevwd( N, 1, x, stride )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.snanstdevwd( N, 1, x1, stride )\n ~2.0817\n\nbase.strided.snanstdevwd.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevwd.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.nanstdevwd, base.strided.snanstdev, base.strided.snanvariancewd, base.strided.sstdevwd\n"
+base.strided.snanstdevwd.ndarray,"\nbase.strided.snanstdevwd.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using Welford's algorithm and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevwd.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevwd, base.strided.nanstdevwd, base.strided.snanstdev, base.strided.snanvariancewd, base.strided.sstdevwd"
base.strided.snanstdevyc,"\nbase.strided.snanstdevyc( N, correction, x, stride )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass algorithm proposed by\n Youngs and Cramer.\n\n The `N` and `stride` parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n If every indexed element is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevyc( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and `stride` parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > base.strided.snanstdevyc( N, 1, x, stride )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > N = base.floor( x0.length / 2 );\n > stride = 2;\n > base.strided.snanstdevyc( N, 1, x1, stride )\n ~2.0817\n\nbase.strided.snanstdevyc.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass algorithm proposed by\n Youngs and Cramer and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevyc.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevyc.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevyc, base.strided.nanstdevyc, base.strided.snanstdev, base.strided.snanvarianceyc, base.strided.sstdevyc\n"
base.strided.snanstdevyc.ndarray,"\nbase.strided.snanstdevyc.ndarray( N, correction, x, stride, offset )\n Computes the standard deviation of a single-precision floating-point strided\n array ignoring `NaN` values and using a one-pass algorithm proposed by\n Youngs and Cramer and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Float32Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snanstdevyc.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.snanstdevyc.ndarray( N, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dnanstdevyc, base.strided.nanstdevyc, base.strided.snanstdev, base.strided.snanvarianceyc, base.strided.sstdevyc"
-base.strided.snansum,"\nbase.strided.snansum( N, x, strideX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snansum( 4, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snansum( 4, x1, 2 )\n -1.0\n\n\nbase.strided.snansum.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansum.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansum, base.strided.gnansum, base.strided.ssum\n"
-base.strided.snansum.ndarray,"\nbase.strided.snansum.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansum.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansum, base.strided.gnansum, base.strided.ssum"
+base.strided.snansum,"\nbase.strided.snansum( N, x, strideX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snansum( 4, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snansum( 4, x1, 2 )\n -1.0\n\n\nbase.strided.snansum.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansum.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansum, base.strided.gnansum, base.strided.snanmean, base.strided.ssum\n"
+base.strided.snansum.ndarray,"\nbase.strided.snansum.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansum.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansum.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansum, base.strided.gnansum, base.strided.snanmean, base.strided.ssum"
base.strided.snansumkbn,"\nbase.strided.snansumkbn( N, x, strideX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using an improved Kahan–Babuška algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansumkbn( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snansumkbn( 4, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snansumkbn( 4, x1, 2 )\n -1.0\n\n\nbase.strided.snansumkbn.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using an improved Kahan–Babuška algorithm and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansumkbn.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansumkbn.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansumkbn, base.strided.gnansumkbn, base.strided.snansum, base.strided.snansumkbn2, base.strided.snansumors, base.strided.snansumpw, base.strided.ssumkbn\n"
base.strided.snansumkbn.ndarray,"\nbase.strided.snansumkbn.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using an improved Kahan–Babuška algorithm and\n alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansumkbn.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansumkbn.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansumkbn, base.strided.gnansumkbn, base.strided.snansum, base.strided.snansumkbn2, base.strided.snansumors, base.strided.snansumpw, base.strided.ssumkbn"
base.strided.snansumkbn2,"\nbase.strided.snansumkbn2( N, x, strideX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `0.0`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansumkbn2( x.length, x, 1 )\n 1.0\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );\n > base.strided.snansumkbn2( 4, x, 2 )\n 1.0\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.snansumkbn2( 4, x1, 2 )\n -1.0\n\n\nbase.strided.snansumkbn2.ndarray( N, x, strideX, offsetX )\n Computes the sum of single-precision floating-point strided array elements,\n ignoring `NaN` values and using a second-order iterative Kahan–Babuška\n algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a starting\n index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n > base.strided.snansumkbn2.ndarray( x.length, x, 1, 0 )\n 1.0\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );\n > base.strided.snansumkbn2.ndarray( 4, x, 2, 1 )\n -1.0\n\n See Also\n --------\n base.strided.dnansumkbn2, base.strided.gnansumkbn2, base.strided.snansum, base.strided.snansumkbn, base.strided.snansumors, base.strided.snansumpw, base.strided.ssumkbn2\n"
@@ -2484,8 +2484,8 @@ base.strided.stdevpn,"\nbase.strided.stdevpn( N, correction, x, strideX )\n C
base.strided.stdevpn.ndarray,"\nbase.strided.stdevpn.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using a two-pass\n algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevpn.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevpn.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevpn, base.strided.nanstdevpn, base.strided.sstdevpn, base.strided.stdev, base.strided.variancepn"
base.strided.stdevtk,"\nbase.strided.stdevtk( N, correction, x, strideX )\n Computes the standard deviation of a strided array using a one-pass textbook\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevtk( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];\n > base.strided.stdevtk( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.stdevtk( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.stdevtk.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using a one-pass textbook\n algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevtk.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevtk, base.strided.nanstdevtk, base.strided.sstdevtk, base.strided.stdev, base.strided.variancetk\n"
base.strided.stdevtk.ndarray,"\nbase.strided.stdevtk.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using a one-pass textbook\n algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevtk.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevtk.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevtk, base.strided.nanstdevtk, base.strided.sstdevtk, base.strided.stdev, base.strided.variancetk"
-base.strided.stdevwd,"\nbase.strided.stdevwd( N, correction, x, strideX )\n Computes the standard deviation of a strided array using Welford's\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];\n > base.strided.stdevwd( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.stdevwd( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.stdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using Welford's algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevwd, base.strided.nanstdevwd, base.strided.stdev, base.strided.variancewd\n"
-base.strided.stdevwd.ndarray,"\nbase.strided.stdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using Welford's algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevwd, base.strided.nanstdevwd, base.strided.stdev, base.strided.variancewd"
+base.strided.stdevwd,"\nbase.strided.stdevwd( N, correction, x, strideX )\n Computes the standard deviation of a strided array using Welford's\n algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];\n > base.strided.stdevwd( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.stdevwd( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.stdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using Welford's algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevwd, base.strided.nanstdevwd, base.strided.sstdevwd, base.strided.stdev, base.strided.variancewd\n"
+base.strided.stdevwd.ndarray,"\nbase.strided.stdevwd.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using Welford's algorithm\n and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevwd.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevwd.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevwd, base.strided.nanstdevwd, base.strided.sstdevwd, base.strided.stdev, base.strided.variancewd"
base.strided.stdevyc,"\nbase.strided.stdevyc( N, correction, x, strideX )\n Computes the standard deviation of a strided array using a one-pass\n algorithm proposed by Youngs and Cramer.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevyc( x.length, 1, x, 1 )\n ~2.0817\n\n // Using `N` and stride parameters:\n > x = [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ];\n > base.strided.stdevyc( 3, 1, x, 2 )\n ~2.0817\n\n // Using view offsets:\n > var x0 = new Float64Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.stdevyc( 3, 1, x1, 2 )\n ~2.0817\n\n\nbase.strided.stdevyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using a one-pass\n algorithm proposed by Youngs and Cramer and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevyc.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevyc.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevyc, base.strided.nanstdevyc, base.strided.sstdevyc, base.strided.stdev, base.strided.varianceyc\n"
base.strided.stdevyc.ndarray,"\nbase.strided.stdevyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the standard deviation of a strided array using a one-pass\n algorithm proposed by Youngs and Cramer and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the offset parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the standard deviation according to `N - c` where `c` corresponds to\n the provided degrees of freedom adjustment. When computing the standard\n deviation of a population, setting this parameter to `0` is the standard\n choice (i.e., the provided array contains data constituting an entire\n population). When computing the corrected sample standard deviation,\n setting this parameter to `1` is the standard choice (i.e., the provided\n array contains data sampled from a larger population; this is commonly\n referred to as Bessel's correction).\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The standard deviation.\n\n Examples\n --------\n // Standard Usage:\n > var x = [ 1.0, -2.0, 2.0 ];\n > base.strided.stdevyc.ndarray( x.length, 1, x, 1, 0 )\n ~2.0817\n\n // Using offset parameter:\n > x = [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ];\n > base.strided.stdevyc.ndarray( 3, 1, x, 2, 1 )\n ~2.0817\n\n See Also\n --------\n base.strided.dstdevyc, base.strided.nanstdevyc, base.strided.sstdevyc, base.strided.stdev, base.strided.varianceyc"
base.strided.strunc,"\nbase.strided.strunc( N, x, strideX, y, strideY )\n Rounds each element in a single-precision floating-point strided array `x`\n toward zero and assigns the results to elements in a single-precision\n floating-point strided array `y`.\n\n The `N` and `stride` parameters determine which elements in `x` and `y` are\n accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n y: Float32Array\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n Returns\n -------\n y: Float32Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float32Array( [ 1.1, 2.5, -3.5, 4.0 ] );\n > var y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > base.strided.strunc( x.length, x, 1, y, 1 )\n [ 1.0, 2.0, -3.0, 4.0 ]\n\n // Using `N` and `stride` parameters:\n > var N = base.floor( x.length / 2 );\n > y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > base.strided.strunc( N, x, 2, y, -1 )\n [ -3.0, 1.0, 0.0, 0.0 ]\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.1, 2.5, -3.5, 4.0 ] );\n > var y0 = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > var y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 );\n > N = base.floor( x0.length / 2 );\n > base.strided.strunc( N, x1, -2, y1, 1 )\n [ 4.0, 2.0 ]\n > y0\n [ 0.0, 0.0, 4.0, 2.0 ]\n\n\nbase.strided.strunc.ndarray( N, x, strideX, offsetX, y, strideY, offsetY )\n Rounds each element in a single-precision floating-point strided array `x`\n toward zero and assigns the results to elements in a single-precision\n floating-point strided array `y` using alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offsetX` and `offsetY` parameters support indexing semantics\n based on starting indices.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Float32Array\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n offsetY: integer\n Starting index for `y`.\n\n Returns\n -------\n y: Float32Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float32Array( [ 1.1, 2.5, -3.5, 4.0 ] );\n > var y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > base.strided.strunc.ndarray( x.length, x, 1, 0, y, 1, 0 )\n [ 1.0, 2.0, -3.0, 4.0 ]\n\n // Advanced indexing:\n > x = new Float32Array( [ 1.1, 2.5, -3.5, 4.0 ] );\n > y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.strided.strunc.ndarray( N, x, 2, 1, y, -1, y.length-1 )\n [ 0.0, 0.0, 4.0, 2.0 ]\n\n See Also\n --------\n base.strided.dtrunc, base.strided.sceil, base.strided.sfloor, strided.trunc\n"
@@ -2498,8 +2498,8 @@ base.strided.svariancepn,"\nbase.strided.svariancepn( N, correction, x, strideX
base.strided.svariancepn.ndarray,"\nbase.strided.svariancepn.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using a two-pass algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride Length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancepn.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancepn.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancepn, base.strided.snanvariancepn, base.strided.sstdevpn, base.strided.svariance, base.strided.variancepn"
base.strided.svariancetk,"\nbase.strided.svariancetk( N, correction, x, strideX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass textbook algorithm.\n\n The `N` and stride parameters determine which elements in `x` are accessed\n at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancetk( x.length, 1, x, 1 )\n ~4.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.svariancetk( 3, 1, x, 2 )\n ~4.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.svariancetk( 3, 1, x1, 2 )\n ~4.3333\n\n\nbase.strided.svariancetk.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass textbook algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancetk.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancetk.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancetk, base.strided.snanvariancetk, base.strided.sstdevtk, base.strided.svariance, base.strided.variancetk\n"
base.strided.svariancetk.ndarray,"\nbase.strided.svariancetk.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass textbook algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancetk.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancetk.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancetk, base.strided.snanvariancetk, base.strided.sstdevtk, base.strided.svariance, base.strided.variancetk"
-base.strided.svariancewd,"\nbase.strided.svariancewd( N, correction, x, strideX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride Length.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd( x.length, 1, x, 1 )\n ~4.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.svariancewd( 3, 1, x, 2 )\n ~4.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.svariancewd( 3, 1, x1, 2 )\n ~4.3333\n\n\nbase.strided.svariancewd.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancewd.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancewd, base.strided.snanvariancewd, base.strided.svariance, base.strided.variancewd\n"
-base.strided.svariancewd.ndarray,"\nbase.strided.svariancewd.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancewd.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancewd, base.strided.snanvariancewd, base.strided.svariance, base.strided.variancewd"
+base.strided.svariancewd,"\nbase.strided.svariancewd( N, correction, x, strideX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride Length.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd( x.length, 1, x, 1 )\n ~4.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.svariancewd( 3, 1, x, 2 )\n ~4.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.svariancewd( 3, 1, x1, 2 )\n ~4.3333\n\n\nbase.strided.svariancewd.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancewd.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancewd, base.strided.snanvariancewd, base.strided.sstdevwd, base.strided.svariance, base.strided.variancewd\n"
+base.strided.svariancewd.ndarray,"\nbase.strided.svariancewd.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using Welford's algorithm and alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svariancewd.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svariancewd.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvariancewd, base.strided.snanvariancewd, base.strided.sstdevwd, base.strided.svariance, base.strided.variancewd"
base.strided.svarianceyc,"\nbase.strided.svarianceyc( N, correction, x, strideX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass algorithm proposed by Youngs and Cramer.\n\n The `N` and stride parameters determine which elements in the strided array\n are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use a typed\n array view.\n\n If `N <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svarianceyc( x.length, 1, x, 1 )\n ~4.3333\n\n // Using `N` and stride parameters:\n > x = new Float32Array( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] );\n > base.strided.svarianceyc( 3, 1, x, 2 )\n ~4.3333\n\n // Using view offsets:\n > var x0 = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > base.strided.svarianceyc( 3, 1, x1, 2 )\n ~4.3333\n\n\nbase.strided.svarianceyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass algorithm proposed by Youngs and Cramer and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svarianceyc.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svarianceyc.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvarianceyc, base.strided.snanvarianceyc, base.strided.sstdevyc, base.strided.svariance, base.strided.varianceyc"
base.strided.svarianceyc.ndarray,"\nbase.strided.svarianceyc.ndarray( N, correction, x, strideX, offsetX )\n Computes the variance of a single-precision floating-point strided array\n using a one-pass algorithm proposed by Youngs and Cramer and alternative\n indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameter supports indexing semantics based on a\n starting index.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n correction: number\n Degrees of freedom adjustment. Setting this parameter to a value other\n than `0` has the effect of adjusting the divisor during the calculation\n of the variance according to `N - c` where `c` corresponds to the\n provided degrees of freedom adjustment. When computing the variance of a\n population, setting this parameter to `0` is the standard choice (i.e.,\n the provided array contains data constituting an entire population).\n When computing the unbiased sample variance, setting this parameter to\n `1` is the standard choice (i.e., the provided array contains data\n sampled from a larger population; this is commonly referred to as\n Bessel's correction).\n\n x: Float32Array\n Input array.\n\n strideX: integer\n Stride length.\n\n offsetX: integer\n Starting index.\n\n Returns\n -------\n out: number\n The variance.\n\n Examples\n --------\n // Standard Usage:\n > var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );\n > base.strided.svarianceyc.ndarray( x.length, 1, x, 1, 0 )\n ~4.3333\n\n // Using offset parameter:\n > var x = new Float32Array( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );\n > base.strided.svarianceyc.ndarray( 3, 1, x, 2, 1 )\n ~4.3333\n\n See Also\n --------\n base.strided.dvarianceyc, base.strided.snanvarianceyc, base.strided.sstdevyc, base.strided.svariance, base.strided.varianceyc"
base.strided.ternary,"\nbase.strided.ternary( arrays, shape, strides, fcn )\n Applies a ternary callback to strided input array elements and assigns\n results to elements in a strided output array.\n\n The `shape` and `strides` parameters determine which elements in the strided\n input and output arrays are accessed at runtime.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n Parameters\n ----------\n arrays: ArrayLikeObject\n Array-like object containing three strided input arrays and one strided\n output array.\n\n shape: ArrayLikeObject\n Array-like object containing a single element, the number of indexed\n elements.\n\n strides: ArrayLikeObject\n Array-like object containing the stride lengths for the strided input\n and output arrays.\n\n fcn: Function\n Ternary callback.\n\n Examples\n --------\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var y = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var z = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > var shape = [ x.length ];\n > var strides = [ 1, 1, 1, 1 ];\n > function f( x, y, z ) { return x + y + z; };\n > base.strided.ternary( [ x, y, z, w ], shape, strides, f );\n > w\n [ 3.0, 6.0, 9.0, 12.0 ]\n\n\nbase.strided.ternary.ndarray( arrays, shape, strides, offsets, fcn )\n Applies a ternary callback to strided input array elements and assigns\n results to elements in a strided output array using alternative indexing\n semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offsets` parameter supports indexing semantics based on\n starting indices.\n\n Parameters\n ----------\n arrays: ArrayLikeObject\n Array-like object containing three strided input arrays and one strided\n output array.\n\n shape: ArrayLikeObject\n Array-like object containing a single element, the number of indexed\n elements.\n\n strides: ArrayLikeObject\n Array-like object containing the stride lengths for the strided input\n and output arrays.\n\n offsets: ArrayLikeObject\n Array-like object containing the starting indices (i.e., index offsets)\n for the strided input and output arrays.\n\n fcn: Function\n Ternary callback.\n\n Examples\n --------\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var y = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var z = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );\n > var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );\n > var shape = [ x.length ];\n > var strides = [ 1, 1, 1, 1 ];\n > var offsets = [ 0, 0, 0, 0 ];\n > function f( x, y, z ) { return x + y + z; };\n > base.strided.ternary.ndarray( [ x, y, z, w ], shape, strides, offsets, f );\n > w\n [ 3.0, 6.0, 9.0, 12.0 ]\n\n See Also\n --------\n base.strided.binary, base.strided.nullary, base.strided.quaternary, base.strided.quinary, base.strided.unary\n"
diff --git a/lib/node_modules/@stdlib/repl/help/data/data.json b/lib/node_modules/@stdlib/repl/help/data/data.json
index 1c2694555a3d..ef0f22099aab 100644
--- a/lib/node_modules/@stdlib/repl/help/data/data.json
+++ b/lib/node_modules/@stdlib/repl/help/data/data.json
@@ -1 +1 @@
-{"abs":"\nabs( x[, options] )\n Computes the absolute value.\n\n If provided a number, the function returns a number.\n\n If provided an ndarray or array-like object, the function performs element-\n wise computation.\n\n If provided an array-like object, the function returns an array-like object\n having the same length and data type as `x`.\n\n If provided an ndarray, the function returns an ndarray having the same\n shape and data type as `x`.\n\n Parameters\n ----------\n x: ndarray|ArrayLikeObject|number\n Input value.\n\n options: Object (optional)\n Options.\n\n options.order: string (optional)\n Output array order (either row-major (C-style) or column-major (Fortran-\n style)). Only applicable when the input array is an ndarray. By default,\n the output array order is inferred from the input array.\n\n options.dtype: string (optional)\n Output array data type. Only applicable when the input array is either\n an ndarray or array-like object. By default, the output array data type\n is inferred from the input array.\n\n Returns\n -------\n y: ndarray|ArrayLikeObject|number\n Results.\n\n Examples\n --------\n // Provide a number:\n > var y = abs( -1.0 )\n 1.0\n\n // Provide an array-like object:\n > var x = new Float64Array( [ -1.0, -2.0 ] );\n > y = abs( x )\n [ 1.0, 2.0 ]\n\n > x = [ -1.0, -2.0 ];\n > y = abs( x )\n [ 1.0, 2.0 ]\n\n // Provide an ndarray:\n > x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );\n > y = abs( x )\n \n > y.get( 0, 1 )\n 2.0\n\n\nabs.assign( x, y )\n Computes the absolute value and assigns results to a provided output array.\n\n Parameters\n ----------\n x: ndarray|ArrayLikeObject\n Input array.\n\n y: ndarray|ArrayLikeObject\n Output array. Must be the same data \"kind\" (i.e., ndarray or array-like\n object) as the input array.\n\n Returns\n -------\n y: ndarray|ArrayLikeObject\n Output array.\n\n Examples\n --------\n // Provide an array-like object:\n > var x = new Float64Array( [ -1.0, -2.0 ] );\n > var y = new Float64Array( x.length );\n > var out = abs.assign( x, y )\n [ 1.0, 2.0 ]\n > var bool = ( out === y )\n true\n\n > x = [ -1.0, -2.0 ];\n > y = [ 0.0, 0.0 ];\n > out = abs.assign( x, y )\n [ 1.0, 2.0 ]\n > bool = ( out === y )\n true\n\n // Provide an ndarray:\n > x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );\n > y = array( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ] );\n > out = abs.assign( x, y )\n \n > out.get( 0, 1 )\n 2.0\n > bool = ( out === y )\n true\n\n","abs.assign":"\nabs.assign( x, y )\n Computes the absolute value and assigns results to a provided output array.\n\n Parameters\n ----------\n x: ndarray|ArrayLikeObject\n Input array.\n\n y: ndarray|ArrayLikeObject\n Output array. Must be the same data \"kind\" (i.e., ndarray or array-like\n object) as the input array.\n\n Returns\n -------\n y: ndarray|ArrayLikeObject\n Output array.\n\n Examples\n --------\n // Provide an array-like object:\n > var x = new Float64Array( [ -1.0, -2.0 ] );\n > var y = new Float64Array( x.length );\n > var out = abs.assign( x, y )\n [ 1.0, 2.0 ]\n > var bool = ( out === y )\n true\n\n > x = [ -1.0, -2.0 ];\n > y = [ 0.0, 0.0 ];\n > out = abs.assign( x, y )\n [ 1.0, 2.0 ]\n > bool = ( out === y )\n true\n\n // Provide an ndarray:\n > x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );\n > y = array( [ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ] );\n > out = abs.assign( x, y )\n \n > out.get( 0, 1 )\n 2.0\n > bool = ( out === y )\n true","acartesianPower":"\nacartesianPower( x, n )\n Returns the Cartesian power.\n\n If provided an empty array, the function returns an empty array.\n\n If `n` is less than or equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n n: integer\n Power.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var x = [ 1, 2 ];\n > var out = acartesianPower( x, 2 )\n [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ]\n\n See Also\n --------\n acartesianProduct, acartesianSquare\n","acartesianProduct":"\nacartesianProduct( x1, x2 )\n Returns the Cartesian product.\n\n If provided one or more empty arrays, the function returns an empty array.\n\n Parameters\n ----------\n x1: ArrayLikeObject\n First input array.\n\n x2: ArrayLikeObject\n Second input array.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var x1 = [ 1, 2 ];\n > var x2 = [ 3, 4 ];\n > var out = acartesianProduct( x1, x2 )\n [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ] ]\n\n See Also\n --------\n acartesianPower, acartesianSquare\n","acartesianSquare":"\nacartesianSquare( x )\n Returns the Cartesian square.\n\n If provided an empty array, the function returns an empty array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var out = acartesianSquare( [ 1, 2 ] )\n [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ]\n\n See Also\n --------\n acartesianPower, acartesianProduct\n","acronym":"\nacronym( str[, options] )\n Generates an acronym for a given string.\n\n Parameters\n ----------\n str: string\n Input string.\n\n options: Object (optional)\n Options.\n\n options.stopwords: Array (optional)\n Array of custom stop words.\n\n Returns\n -------\n out: string\n Acronym for the given string.\n\n Examples\n --------\n > var out = acronym( 'the quick brown fox' )\n 'QBF'\n > out = acronym( 'Hard-boiled eggs' )\n 'HBE'\n","aempty":"\naempty( length[, dtype] )\n Creates an uninitialized array having a specified length.\n\n In browser environments, the function always returns zero-filled arrays.\n\n If `dtype` is 'generic', the function always returns a zero-filled array.\n\n In Node.js versions >=3.0.0, the underlying memory of returned typed arrays\n is *not* initialized. Memory contents are unknown and may contain\n *sensitive* data.\n\n Parameters\n ----------\n length: integer\n Array length.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = aempty( 2 )\n \n > arr = aempty( 2, 'float32' )\n \n\n See Also\n --------\n aemptyLike, afull, aones, azeros, ndempty\n","aemptyLike":"\naemptyLike( x[, dtype] )\n Creates an uninitialized array having the same length and data type as a\n provided input array.\n\n In browser environments, the function always returns zero-filled arrays.\n\n If `dtype` is 'generic', the function always returns a zero-filled array.\n\n In Node.js versions >=3.0.0, the underlying memory of returned typed arrays\n is *not* initialized. Memory contents are unknown and may contain\n *sensitive* data.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var x = new Float64Array( 2 );\n > var arr = aemptyLike( x )\n \n > arr = aemptyLike( x, 'float32' )\n \n\n See Also\n --------\n aempty, afullLike, aonesLike, azerosLike, ndemptyLike\n","AFINN_96":"\nAFINN_96()\n Returns a list of English words rated for valence.\n\n The returned list contains 1468 English words (and phrases) rated for\n valence. Negative words have a negative valence [-5,0). Positive words have\n a positive valence (0,5]. Neutral words have a valence of 0.\n\n A few notes:\n\n - The list is an earlier version of AFINN-111.\n - The list includes misspelled words. Their presence is intentional, as such\n misspellings frequently occur in social media content.\n - All words are lowercase.\n - Some \"words\" are phrases; e.g., \"cashing in\", \"cool stuff\".\n - Words may contain apostrophes; e.g., \"can't stand\".\n - Words may contain dashes; e.g., \"cover-up\", \"made-up\".\n\n Returns\n -------\n out: Array\n List of English words and their valence.\n\n Examples\n --------\n > var list = AFINN_96()\n [ [ 'abandon', -2 ], [ 'abandons', -2 ], [ 'abandoned', -2 ], ... ]\n\n References\n ----------\n - Nielsen, Finn Årup. 2011. \"A new ANEW: Evaluation of a word list for\n sentiment analysis in microblogs.\" In *Proceedings of the ESWC2011 Workshop\n on 'Making Sense of Microposts': Big Things Come in Small Packages.*,\n 718:93–98. CEUR Workshop Proceedings. .\n\n * If you use the list for publication or third party consumption, please\n cite the listed reference.\n\n See Also\n --------\n AFINN_111\n","AFINN_111":"\nAFINN_111()\n Returns a list of English words rated for valence.\n\n The returned list contains 2477 English words (and phrases) rated for\n valence. Negative words have a negative valence [-5,0). Positive words have\n a positive valence (0,5]. Neutral words have a valence of 0.\n\n A few notes:\n\n - The list includes misspelled words. Their presence is intentional, as such\n misspellings frequently occur in social media content.\n - All words are lowercase.\n - Words may contain numbers; e.g., \"n00b\".\n - Some \"words\" are phrases; e.g., \"cool stuff\", \"not good\".\n - Words may contain apostrophes; e.g., \"can't stand\".\n - Words may contain diaeresis; e.g., \"naïve\".\n - Words may contain dashes; e.g., \"self-deluded\", \"self-confident\".\n\n Returns\n -------\n out: Array\n List of English words and their valence.\n\n Examples\n --------\n > var list = AFINN_111()\n [ [ 'abandon', -2 ], [ 'abandoned', -2 ], [ 'abandons', -2 ], ... ]\n\n References\n ----------\n - Nielsen, Finn Årup. 2011. \"A new ANEW: Evaluation of a word list for\n sentiment analysis in microblogs.\" In *Proceedings of the ESWC2011 Workshop\n on 'Making Sense of Microposts': Big Things Come in Small Packages.*,\n 718:93–98. CEUR Workshop Proceedings. .\n\n * If you use the list for publication or third party consumption, please\n cite the listed reference.\n\n See Also\n --------\n AFINN_96\n","afull":"\nafull( length, value[, dtype] )\n Returns a filled array having a specified length.\n\n Parameters\n ----------\n length: integer\n Array length.\n\n value: any\n Fill value.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = afull( 2, 1.0 )\n [ 1.0, 1.0 ]\n > arr = afull( 2, 1.0, 'float32' )\n [ 1.0, 1.0 ]\n\n See Also\n --------\n afullLike, aones, azeros\n","afullLike":"\nafullLike( x[, dtype] )\n Returns a filled array having the same length and data type as a provided\n input array.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var x = new Float64Array( 2 );\n > var y = afullLike( x, 1.0 )\n [ 1.0, 1.0 ]\n > y = afullLike( x, 1.0, 'float32' )\n [ 1.0, 1.0 ]\n\n See Also\n --------\n afull, aonesLike, azerosLike\n","alias2pkg":"\nalias2pkg( alias )\n Returns the package name associated with a provided alias.\n\n Parameters\n ----------\n alias: string\n Alias.\n\n Returns\n -------\n out: string|null\n Package name.\n\n Examples\n --------\n > var v = alias2pkg( 'base.sin' )\n '@stdlib/math/base/special/sin'\n\n See Also\n --------\n alias2related, aliases, pkg2alias\n","alias2related":"\nalias2related( alias )\n Returns aliases related to a specified alias.\n\n Parameters\n ----------\n alias: string\n Alias.\n\n Returns\n -------\n out: Array|null\n Related aliases.\n\n Examples\n --------\n > var v = alias2related( 'base.sin' )\n [...]\n\n See Also\n --------\n alias2pkg, aliases, pkg2related\n","alias2standalone":"\nalias2standalone( alias )\n Returns the standalone package name associated with a provided alias.\n\n Parameters\n ----------\n alias: string\n Alias.\n\n Returns\n -------\n out: string|null\n Standalone package name.\n\n Examples\n --------\n > var v = alias2standalone( 'base.sin' )\n '@stdlib/math-base-special-sin'\n\n See Also\n --------\n alias2pkg, alias2related, aliases, pkg2alias, pkg2standalone\n","aliases":"\naliases( [namespace] )\n Returns a list of standard library aliases.\n\n Parameters\n ----------\n namespace: string (optional)\n Namespace filter.\n\n Returns\n -------\n out: Array\n List of aliases.\n\n Examples\n --------\n > var o = aliases()\n [...]\n > o = aliases( '@stdlib/math/base/special' )\n [...]\n\n See Also\n --------\n alias2pkg, alias2related, pkg2alias\n","allocUnsafe":"\nallocUnsafe( size )\n Allocates a buffer having a specified number of bytes.\n\n The underlying memory of returned buffers is not initialized. Memory\n contents are unknown and may contain sensitive data.\n\n When the size is less than half a buffer pool size, memory is allocated from\n the buffer pool for faster allocation of Buffer instances.\n\n Parameters\n ----------\n size: integer\n Number of bytes to allocate.\n\n Returns\n -------\n out: Buffer\n Buffer instance.\n\n Examples\n --------\n > var buf = allocUnsafe( 100 )\n \n\n See Also\n --------\n Buffer, array2buffer, arraybuffer2buffer, copyBuffer, string2buffer\n","amskfilter":"\namskfilter( x, mask )\n Returns a new array by applying a mask to a provided input array.\n\n If a mask array element is truthy, the corresponding element in `x` is\n included in the output array; otherwise, the corresponding element in `x` is\n \"masked\" and thus excluded from the output array.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n mask: Array|TypedArray|Object\n Mask array.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Output array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var y = amskfilter( x, [ 0, 1, 0, 1 ] )\n [ 2, 4 ]\n\n See Also\n --------\n amskreject\n","amskput":"\namskput( x, mask, values[, options] )\n Replaces elements of an array with provided values according to a provided\n mask array.\n\n In broadcasting modes, the function supports broadcasting a values array\n containing a single element against the number of falsy values in the mask\n array.\n\n In repeat mode, the function supports recycling elements in a values array\n to satisfy the number of falsy values in the mask array.\n\n The function mutates the input array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n mask: ArrayLikeObject\n Mask array. If a mask array element is falsy, the corresponding element\n in `x` is *replaced*; otherwise, the corresponding element in `x` is\n \"masked\" and thus left unchanged.\n\n values: ArrayLikeObject\n Values to set.\n\n options: Object (optional)\n Function options.\n\n options.mode: string (optional)\n String specifying behavior when the number of values to set does not\n equal the number of falsy mask values. The function supports the\n following modes:\n\n - 'strict': specifies that the function must raise an exception when the\n number of values does not *exactly* equal the number of falsy mask\n values.\n - 'non_strict': specifies that the function must raise an exception when\n the function is provided insufficient values to satisfy the mask array.\n - 'strict_broadcast': specifies that the function must broadcast a\n single-element values array and otherwise raise an exception when the\n number of values does not **exactly** equal the number of falsy mask\n values.\n - 'broadcast': specifies that the function must broadcast a single-\n element values array and otherwise raise an exception when the function\n is provided insufficient values to satisfy the mask array.\n - 'repeat': specifies that the function must reuse provided values when\n replacing elements in `x` in order to satisfy the mask array.\n\n Default: 'repeat'.\n\n Returns\n -------\n out: ArrayLikeObject\n Input array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var out = amskput( x, [ 1, 0, 1, 0 ], [ 20, 40 ] )\n [ 1, 20, 3, 40 ]\n > var bool = ( out === x )\n true\n\n See Also\n --------\n aplace, aput, atake\n","amskreject":"\namskreject( x, mask )\n Returns a new array by applying a mask to a provided input array.\n\n If a mask array element is falsy, the corresponding element in `x` is\n included in the output array; otherwise, the corresponding element in `x` is\n \"masked\" and thus excluded from the output array.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n mask: Array|TypedArray|Object\n Mask array.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Output array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var y = amskreject( x, [ 0, 1, 0, 1 ] )\n [ 1, 3 ]\n\n See Also\n --------\n amskfilter\n","anans":"\nanans( length[, dtype] )\n Returns an array filled with NaNs and having a specified length.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754)\n - float32: single-precision floating-point numbers (IEEE 754)\n - complex128: double-precision complex floating-point numbers\n - complex64: single-precision complex floating-point numbers\n - generic: generic JavaScript values\n\n The default array data type is `float64`.\n\n Parameters\n ----------\n length: integer\n Array length.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = anans( 2 )\n [ NaN, NaN ]\n > arr = anans( 2, 'float32' )\n [ NaN, NaN ]\n\n See Also\n --------\n afull, anansLike, aones, azeros\n","anansLike":"\nanansLike( x[, dtype] )\n Returns an array filled with NaNs and having the same length and data type\n as a provided input array.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - generic: generic JavaScript values.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var x = new Float64Array( 2 );\n > var y = anansLike( x )\n [ NaN, NaN ]\n > y = anansLike( x, 'float32' )\n [ NaN, NaN ]\n\n See Also\n --------\n afullLike, anans, aonesLike, azerosLike\n","anova1":"\nanova1( x, factor[, options] )\n Performs a one-way analysis of variance.\n\n Parameters\n ----------\n x: Array\n Measured values.\n\n factor: Array\n Array of treatments.\n\n options: Object (optional)\n Options.\n\n options.alpha: number (optional)\n Number in the interval `[0,1]` giving the significance level of the\n hypothesis test. Default: `0.05`.\n\n Returns\n -------\n out: Object\n Test result object.\n\n out.alpha: number\n Significance level.\n\n out.rejected: boolean\n Test decision.\n\n out.pValue: number\n p-value of the test.\n\n out.statistic: number\n Value of test statistic.\n\n out.method: string\n Name of test.\n\n out.means: Object\n Group means alongside sample sizes and standard errors.\n\n out.treatment: Object\n Treatment results.\n\n out.treatment.df: number\n Treatment degrees of freedom.\n\n out.treatment.ss: number\n Treatment sum of squares.\n\n out.treatment.ms: number\n Treatment mean sum of squares.\n\n out.error: Object\n Error results.\n\n out.error.df: number\n Error degrees of freedom.\n\n out.error.ss: number\n Error sum of squares.\n\n out.error.ms: number\n Error mean sum of squares.\n\n out.print: Function\n Function to print formatted output.\n\n Examples\n --------\n > var x = [1, 3, 5, 2, 4, 6, 8, 7, 10, 11, 12, 15];\n > var f = [\n ... 'control', 'treatA', 'treatB', 'treatC', 'control',\n ... 'treatA', 'treatB', 'treatC', 'control', 'treatA', 'treatB', 'treatC'\n ... ];\n > var out = anova1( x, f )\n {...}\n\n","ANSCOMBES_QUARTET":"\nANSCOMBES_QUARTET()\n Returns Anscombe's quartet.\n\n Anscombe's quartet is a set of 4 datasets which all have nearly identical\n simple statistical properties but vary considerably when graphed. Anscombe\n created the datasets to demonstrate why graphical data exploration should\n precede statistical data analysis and to show the effect of outliers on\n statistical properties.\n\n Returns\n -------\n out: Array\n Anscombe's quartet.\n\n Examples\n --------\n > var d = ANSCOMBES_QUARTET()\n [[[10,8.04],...],[[10,9.14],...],[[10,7.46],...],[[8,6.58],...]]\n\n References\n ----------\n - Anscombe, Francis J. 1973. \"Graphs in Statistical Analysis.\" *The American\n Statistician* 27 (1). [American Statistical Association, Taylor & Francis,\n Ltd.]: 17–21. .\n\n","any":"\nany( collection )\n Tests whether at least one element in a collection is truthy.\n\n The function immediately returns upon encountering a truthy value.\n\n If provided an empty collection, the function returns `false`.\n\n Parameters\n ----------\n collection: Array|TypedArray|Object\n Input collection over which to iterate. If provided an object, the\n object must be array-like (excluding strings and functions).\n\n Returns\n -------\n bool: boolean\n The function returns `true` if an element is truthy; otherwise, the\n function returns `false`.\n\n Examples\n --------\n > var arr = [ 0, 0, 0, 0, 1 ];\n > var bool = any( arr )\n true\n\n See Also\n --------\n anyBy, every, forEach, none, some\n","anyBy":"\nanyBy( collection, predicate[, thisArg ] )\n Tests whether at least one element in a collection passes a test implemented\n by a predicate function.\n\n The predicate function is provided three arguments:\n\n - value: collection value.\n - index: collection index.\n - collection: the input collection.\n\n The function immediately returns upon encountering a truthy return value.\n\n If provided an empty collection, the function returns `false`.\n\n Parameters\n ----------\n collection: Array|TypedArray|Object\n Input collection over which to iterate. If provided an object, the\n object must be array-like (excluding strings and functions).\n\n predicate: Function\n The test function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n bool: boolean\n The function returns `true` if the predicate function returns `true` for\n any element; otherwise, the function returns `false`.\n\n Examples\n --------\n > function negative( v ) { return ( v < 0 ); };\n > var arr = [ 1, 2, 3, 4, -1 ];\n > var bool = anyBy( arr, negative )\n true\n\n See Also\n --------\n anyByAsync, anyByRight, everyBy, forEach, noneBy, someBy\n","anyByAsync":"\nanyByAsync( collection, [options,] predicate, done )\n Tests whether at least one element in a collection passes a test implemented\n by a predicate function.\n\n When invoked, the predicate function is provided a maximum of four\n arguments:\n\n - value: collection value.\n - index: collection index.\n - collection: the input collection.\n - next: a callback to be invoked after processing a collection `value`.\n\n The actual number of provided arguments depends on function length. If the\n predicate function accepts two arguments, the predicate function is\n provided:\n\n - value\n - next\n\n If the predicate function accepts three arguments, the predicate function is\n provided:\n\n - value\n - index\n - next\n\n For every other predicate function signature, the predicate function is\n provided all four arguments.\n\n The `next` callback takes two arguments:\n\n - error: error argument.\n - result: test result.\n\n If a provided function calls the `next` callback with a truthy `error`\n argument, the function suspends execution and immediately calls the `done`\n callback for subsequent `error` handling.\n\n The function immediately returns upon encountering a non-falsy `result`\n value and calls the `done` callback with `null` as the first argument and\n `true` as the second argument.\n\n If all elements fail, the function calls the `done` callback with `null`\n as the first argument and `false` as the second argument.\n\n Execution is *not* guaranteed to be asynchronous. To guarantee asynchrony,\n wrap the `done` callback in a function which either executes at the end of\n the current stack (e.g., `nextTick`) or during a subsequent turn of the\n event loop (e.g., `setImmediate`, `setTimeout`).\n\n The function does not support dynamic collection resizing.\n\n The function does not skip `undefined` elements.\n\n Parameters\n ----------\n collection: Array|TypedArray|Object\n Input collection over which to iterate. If provided an object, the\n object must be array-like (excluding strings and functions).\n\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n done: Function\n A callback invoked either upon processing all collection elements or\n upon encountering an error.\n\n Examples\n --------\n // Basic usage:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 3000, 2500, 1000 ];\n > anyByAsync( arr, predicate, done )\n 1000\n 2500\n 3000\n false\n\n // Limit number of concurrent invocations:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var opts = { 'limit': 2 };\n > var arr = [ 3000, 2500, 1000 ];\n > anyByAsync( arr, opts, predicate, done )\n 2500\n 3000\n 1000\n false\n\n // Process sequentially:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var opts = { 'series': true };\n > var arr = [ 3000, 2500, 1000 ];\n > anyByAsync( arr, opts, predicate, done )\n 3000\n 2500\n 1000\n false\n\n\nanyByAsync.factory( [options,] predicate )\n Returns a function which tests whether at least one element in a collection\n passes a test implemented by a predicate function.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n Returns\n -------\n out: Function\n A function which tests each element in a collection.\n\n Examples\n --------\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > var opts = { 'series': true };\n > var f = anyByAsync.factory( opts, predicate );\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 3000, 2500, 1000 ];\n > f( arr, done )\n 3000\n 2500\n 1000\n false\n > arr = [ 2000, 1500, 1000 ];\n > f( arr, done )\n 2000\n 1500\n 1000\n false\n\n See Also\n --------\n anyBy, anyByRightAsync, everyByAsync, forEachAsync, noneByAsync, someByAsync\n","anyByAsync.factory":"\nanyByAsync.factory( [options,] predicate )\n Returns a function which tests whether at least one element in a collection\n passes a test implemented by a predicate function.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n Returns\n -------\n out: Function\n A function which tests each element in a collection.\n\n Examples\n --------\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > var opts = { 'series': true };\n > var f = anyByAsync.factory( opts, predicate );\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 3000, 2500, 1000 ];\n > f( arr, done )\n 3000\n 2500\n 1000\n false\n > arr = [ 2000, 1500, 1000 ];\n > f( arr, done )\n 2000\n 1500\n 1000\n false\n\n See Also\n --------\n anyBy, anyByRightAsync, everyByAsync, forEachAsync, noneByAsync, someByAsync","anyByRight":"\nanyByRight( collection, predicate[, thisArg ] )\n Tests whether at least one element in a collection passes a test implemented\n by a predicate function, iterating from right to left.\n\n The predicate function is provided three arguments:\n\n - value: collection value.\n - index: collection index.\n - collection: the input collection.\n\n The function immediately returns upon encountering a truthy return value.\n\n If provided an empty collection, the function returns `false`.\n\n Parameters\n ----------\n collection: Array|TypedArray|Object\n Input collection over which to iterate. If provided an object, the\n object must be array-like (excluding strings and functions).\n\n predicate: Function\n The test function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n bool: boolean\n The function returns `true` if the predicate function returns `true` for\n any element; otherwise, the function returns `false`.\n\n Examples\n --------\n > function negative( v ) { return ( v < 0 ); };\n > var arr = [ -1, 1, 2, 3, 4 ];\n > var bool = anyByRight( arr, negative )\n true\n\n See Also\n --------\n anyBy, anyByRightAsync, everyByRight, forEachRight, noneByRight, someByRight\n","anyByRightAsync":"\nanyByRightAsync( collection, [options,] predicate, done )\n Tests whether at least one element in a collection passes a test implemented\n by a predicate function, iterating from right to left.\n\n When invoked, the predicate function is provided a maximum of four\n arguments:\n\n - value: collection value.\n - index: collection index.\n - collection: the input collection.\n - next: a callback to be invoked after processing a collection `value`.\n\n The actual number of provided arguments depends on function length. If the\n predicate function accepts two arguments, the predicate function is\n provided:\n\n - value\n - next\n\n If the predicate function accepts three arguments, the predicate function is\n provided:\n\n - value\n - index\n - next\n\n For every other predicate function signature, the predicate function is\n provided all four arguments.\n\n The `next` callback takes two arguments:\n\n - error: error argument.\n - result: test result.\n\n If a provided function calls the `next` callback with a truthy `error`\n argument, the function suspends execution and immediately calls the `done`\n callback for subsequent `error` handling.\n\n The function immediately returns upon encountering a non-falsy `result`\n value and calls the `done` callback with `null` as the first argument and\n `true` as the second argument.\n\n If all elements fail, the function calls the `done` callback with `null`\n as the first argument and `false` as the second argument.\n\n Execution is *not* guaranteed to be asynchronous. To guarantee asynchrony,\n wrap the `done` callback in a function which either executes at the end of\n the current stack (e.g., `nextTick`) or during a subsequent turn of the\n event loop (e.g., `setImmediate`, `setTimeout`).\n\n The function does not support dynamic collection resizing.\n\n The function does not skip `undefined` elements.\n\n Parameters\n ----------\n collection: Array|TypedArray|Object\n Input collection over which to iterate. If provided an object, the\n object must be array-like (excluding strings and functions).\n\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n done: Function\n A callback invoked either upon processing all collection elements or\n upon encountering an error.\n\n Examples\n --------\n // Basic usage:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 1000, 2500, 3000 ];\n > anyByRightAsync( arr, predicate, done )\n 1000\n 2500\n 3000\n false\n\n // Limit number of concurrent invocations:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var opts = { 'limit': 2 };\n > var arr = [ 1000, 2500, 3000 ];\n > anyByRightAsync( arr, opts, predicate, done )\n 2500\n 3000\n 1000\n false\n\n // Process sequentially:\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var opts = { 'series': true };\n > var arr = [ 1000, 2500, 3000 ];\n > anyByRightAsync( arr, opts, predicate, done )\n 3000\n 2500\n 1000\n false\n\n\nanyByRightAsync.factory( [options,] predicate )\n Returns a function which tests whether at least one element in a collection\n passes a test implemented by a predicate function, iterating from right to\n left.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n Returns\n -------\n out: Function\n A function which tests each element in a collection.\n\n Examples\n --------\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > var opts = { 'series': true };\n > var f = anyByRightAsync.factory( opts, predicate );\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 1000, 2500, 3000 ];\n > f( arr, done )\n 3000\n 2500\n 1000\n false\n > arr = [ 1000, 1500, 2000 ];\n > f( arr, done )\n 2000\n 1500\n 1000\n false\n\n See Also\n --------\n anyByAsync, anyByRight, everyByRightAsync, forEachRightAsync, noneByRightAsync, someByRightAsync\n","anyByRightAsync.factory":"\nanyByRightAsync.factory( [options,] predicate )\n Returns a function which tests whether at least one element in a collection\n passes a test implemented by a predicate function, iterating from right to\n left.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.limit: integer (optional)\n Maximum number of pending invocations. Default: Infinity.\n\n options.series: boolean (optional)\n Boolean indicating whether to process each collection element\n sequentially. Default: false.\n\n options.thisArg: any (optional)\n Execution context.\n\n predicate: Function\n The test function to invoke for each element in a collection.\n\n Returns\n -------\n out: Function\n A function which tests each element in a collection.\n\n Examples\n --------\n > function predicate( value, next ) {\n ... setTimeout( onTimeout, value );\n ... function onTimeout() {\n ... console.log( value );\n ... next( null, false );\n ... }\n ... };\n > var opts = { 'series': true };\n > var f = anyByRightAsync.factory( opts, predicate );\n > function done( error, bool ) {\n ... if ( error ) {\n ... throw error;\n ... }\n ... console.log( bool );\n ... };\n > var arr = [ 1000, 2500, 3000 ];\n > f( arr, done )\n 3000\n 2500\n 1000\n false\n > arr = [ 1000, 1500, 2000 ];\n > f( arr, done )\n 2000\n 1500\n 1000\n false\n\n See Also\n --------\n anyByAsync, anyByRight, everyByRightAsync, forEachRightAsync, noneByRightAsync, someByRightAsync","anyInBy":"\nanyInBy( object, predicate[, thisArg ] )\n Tests whether at least one value in an object passes a test implemented by\n a predicate function.\n\n The predicate function is provided three arguments:\n\n - value: the value of the current property being processed in the object\n - key: the key of the current property being processed in the object\n - object: the input object\n\n The function immediately returns upon encountering a truthy return value.\n\n If provided an empty object, the function returns `false`.\n\n Parameters\n ----------\n object: Object\n Input object over which to iterate. It must be non-null.\n\n predicate: Function\n The test function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n bool: boolean\n The function returns `true` if the predicate function returns `true` for\n any value; otherwise, it returns `false`.\n\n Examples\n --------\n > function isNegative(value) { return value < 0 }\n > var obj = { a: 1, b: -2, c: 3, d: 4 }\n > var result = anyInBy(obj, isNegative)\n true\n\n See Also\n --------\n anyBy, anyOwnBy, everyInBy, someInBy","anyOwnBy":"\nanyOwnBy( object, predicate[, thisArg ] )\n Tests whether at least one own property of an object passes a\n test implemented by a predicate function.\n\n The predicate function is provided three arguments:\n\n - value: property value.\n - index: property key.\n - object: the input object.\n\n The function immediately returns upon encountering a truthy return\n value.\n\n If provided an empty object, the function returns `false`.\n\n Parameters\n ----------\n object: Object\n Input object.\n\n predicate: Function\n Test function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n bool: boolean\n The function returns `true` if the predicate function returns a truthy\n value for one own property; otherwise, the function returns `false`.\n\n Examples\n --------\n > function positive( v ) { return ( v > 0 ); };\n > var obj = { 'a': -1, 'b': 2, 'c': -3 };\n > var bool = anyOwnBy( obj, positive )\n true\n\n See Also\n --------\n anyBy, anyInBy, everyOwnBy, someOwnBy\n","aones":"\naones( length[, dtype] )\n Returns an array filled with ones and having a specified length.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n The default array data type is `float64`.\n\n Parameters\n ----------\n length: integer\n Array length.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = aones( 2 )\n [ 1.0, 1.0 ]\n > arr = aones( 2, 'float32' )\n [ 1.0, 1.0 ]\n\n See Also\n --------\n afull, anans, aonesLike, azeros\n","aonesLike":"\naonesLike( x[, dtype] )\n Returns an array filled with ones and having the same length and data type\n as a provided input array.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var x = new Float64Array( 2 );\n > var y = aonesLike( x )\n [ 1.0, 1.0 ]\n > y = aonesLike( x, 'float32' )\n [ 1.0, 1.0 ]\n\n See Also\n --------\n afullLike, anansLike, aones, azerosLike\n","aoneTo":"\naoneTo( n[, dtype] )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from one.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n The default array data type is `float64`.\n\n If `n` is equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n n: integer\n Number of elements.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = aoneTo( 2 )\n [ 1.0, 2.0 ]\n > arr = aoneTo( 2, 'float32' )\n [ 1.0, 2.0 ]\n\n See Also\n --------\n afull, aones, aoneToLike, azeroTo\n","aoneToLike":"\naoneToLike( x[, dtype] )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from one and having the same length and data type as a provided\n input array.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = aoneToLike( [ 0, 0 ] )\n [ 1, 2 ]\n > arr = aoneToLike( [ 0, 0 ], 'float32' )\n [ 1.0, 2.0 ]\n\n See Also\n --------\n afullLike, aonesLike, aoneTo, azeroToLike\n","APERY":"\nAPERY\n Apéry's constant.\n\n Examples\n --------\n > APERY\n 1.2020569031595942\n\n","aplace":"\naplace( x, mask, values[, options] )\n Replaces elements of an array with provided values according to a provided\n mask array.\n\n In broadcasting modes, the function supports broadcasting a values array\n containing a single element against the number of truthy values in the mask\n array.\n\n In repeat mode, the function supports recycling elements in a values array\n to satisfy the number of truthy values in the mask array.\n\n The function mutates the input array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n mask: ArrayLikeObject\n Mask array. If a mask array element is truthy, the corresponding element\n in `x` is *replaced*; otherwise, the corresponding element in `x` is\n \"masked\" and thus left unchanged.\n\n values: ArrayLikeObject\n Values to set.\n\n options: Object (optional)\n Function options.\n\n options.mode: string (optional)\n String specifying behavior when the number of values to set does not\n equal the number of truthy mask values. The function supports the\n following modes:\n\n - 'strict': specifies that the function must raise an exception when the\n number of values does not *exactly* equal the number of truthy mask\n values.\n - 'non_strict': specifies that the function must raise an exception when\n the function is provided insufficient values to satisfy the mask array.\n - 'strict_broadcast': specifies that the function must broadcast a\n single-element values array and otherwise raise an exception when the\n number of values does not **exactly** equal the number of truthy mask\n values.\n - 'broadcast': specifies that the function must broadcast a single-\n element values array and otherwise raise an exception when the function\n is provided insufficient values to satisfy the mask array.\n - 'repeat': specifies that the function must reuse provided values when\n replacing elements in `x` in order to satisfy the mask array.\n\n Default: 'repeat'.\n\n Returns\n -------\n out: ArrayLikeObject\n Input array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var out = aplace( x, [ 0, 1, 0, 1 ], [ 20, 40 ] )\n [ 1, 20, 3, 40 ]\n > var bool = ( out === x )\n true\n\n See Also\n --------\n amskput, aput, atake\n","append":"\nappend( collection1, collection2 )\n Adds the elements of one collection to the end of another collection.\n\n If the input collection is a typed array, the output value does not equal\n the input reference and the underlying `ArrayBuffer` may *not* be the same\n as the `ArrayBuffer` belonging to the input view.\n\n For purposes of generality, always treat the output collection as distinct\n from the input collection.\n\n Parameters\n ----------\n collection1: Array|TypedArray|Object\n A collection. If the collection is an `Object`, the collection should be\n array-like.\n\n collection2: Array|TypedArray|Object\n A collection containing the elements to add. If the collection is an\n `Object`, the collection should be array-like.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Updated collection.\n\n Examples\n --------\n // Arrays:\n > var arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\n > arr = append( arr, [ 6.0, 7.0 ] )\n [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ]\n\n // Typed arrays:\n > arr = new Float64Array( [ 1.0, 2.0 ] );\n > arr = append( arr, [ 3.0, 4.0 ] )\n [ 1.0, 2.0, 3.0, 4.0 ]\n\n // Array-like object:\n > arr = { 'length': 0 };\n > arr = append( arr, [ 1.0, 2.0 ] )\n { 'length': 2, '0': 1.0, '1': 2.0 }\n\n See Also\n --------\n prepend, push\n","aput":"\naput( x, indices, values[, options] )\n Replaces specified elements of an array with provided values.\n\n The function supports broadcasting a `values` array containing a single\n element against an `indices` array containing one or more elements.\n\n The function mutates the input array.\n\n Because each index is only validated at the time of replacing a particular\n element, mutation may occur even when one or more indices are out-of-bounds,\n including when the index mode indicates to raise an exception.\n\n If `indices` is an empty array, the function returns the input array\n unchanged.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n indices: ArrayLikeObject\n List of element indices.\n\n values: ArrayLikeObject\n Values to set. When `indices` contains one or more elements, `values`\n must be broadcast compatible with `indices` (i.e., must have either one\n element or the same number of elements as `indices`).\n\n options: Object (optional)\n Function options.\n\n options.mode: string (optional)\n Specifies how to handle an index outside the interval [0, max], where\n `max` is the maximum possible array index. If equal to 'throw', the\n function throws an error. If equal to 'normalize', the function throws\n an error if provided an out-of-bounds normalized index. If equal to\n 'wrap', the function wraps around an index using modulo arithmetic. If\n equal to 'clamp', the function sets an index to either 0 (minimum index)\n or the maximum index. Default: 'normalize'.\n\n Returns\n -------\n out: ArrayLikeObject\n Input array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var out = aput( x, [ 1, 3 ], [ 20, 40 ] )\n [ 1, 20, 3, 40 ]\n > var bool = ( out === x )\n true\n\n See Also\n --------\n amskput, aplace, atake\n","ARCH":"\nARCH\n Operating system CPU architecture for which the JavaScript runtime binary\n was compiled.\n\n Current possible values:\n\n - arm\n - arm64\n - ia32\n - mips\n - mipsel\n - ppc\n - ppc64\n - s390\n - s390x\n - x32\n - x64\n\n Examples\n --------\n > ARCH\n \n\n See Also\n --------\n PLATFORM\n","argumentFunction":"\nargumentFunction( idx )\n Returns a function which always returns a specified argument.\n\n The input argument corresponds to the zero-based index of the argument to\n return.\n\n Parameters\n ----------\n idx: integer\n Argument index to return (zero-based).\n\n Returns\n -------\n out: Function\n Argument function.\n\n Examples\n --------\n > var argn = argumentFunction( 1 );\n > var v = argn( 3.14, -3.14, 0.0 )\n -3.14\n > v = argn( -1.0, -0.0, 1.0 )\n -0.0\n > v = argn( 'beep', 'boop', 'bop' )\n 'boop'\n > v = argn( 'beep' )\n undefined\n\n See Also\n --------\n constantFunction, identity\n","ARGV":"\nARGV\n An array containing command-line arguments passed when launching the calling\n process.\n\n The first element is the absolute pathname of the executable that started\n the calling process.\n\n The second element is the path of the executed file.\n\n Any additional elements are additional command-line arguments.\n\n In browser environments, the array is empty.\n\n Examples\n --------\n > var execPath = ARGV[ 0 ]\n e.g., /usr/local/bin/node\n\n See Also\n --------\n ENV\n","array":"\narray( [buffer,] [options] )\n Returns a multidimensional array.\n\n Parameters\n ----------\n buffer: Array|TypedArray|Buffer|ndarray (optional)\n Data source.\n\n options: Object (optional)\n Options.\n\n options.buffer: Array|TypedArray|Buffer|ndarray (optional)\n Data source. If provided along with a `buffer` argument, the argument\n takes precedence.\n\n options.dtype: string (optional)\n Underlying storage data type. If not specified and a data source is\n provided, the data type is inferred from the provided data source. If an\n input data source is not of the same type, this option specifies the\n data type to which to cast the input data. For non-ndarray generic array\n data sources, the function casts generic array data elements to the\n default data type. In order to prevent this cast, the `dtype` option\n must be explicitly set to `'generic'`. Any time a cast is required, the\n `copy` option is set to `true`, as memory must be copied from the data\n source to an output data buffer. Default: 'float64'.\n\n options.order: string (optional)\n Specifies the memory layout of the data source as either row-major (C-\n style) or column-major (Fortran-style). The option may be one of the\n following values:\n\n - 'row-major': the order of the returned array is row-major.\n - 'column-major': the order of the returned array is column-major.\n - 'any': if a data source is column-major and not row-major, the order\n of the returned array is column-major; otherwise, the order of the\n returned array is row-major.\n - 'same': the order of the returned array matches the order of an input\n data source.\n\n Note that specifying an order which differs from the order of a\n provided data source does *not* entail a conversion from one memory\n layout to another. In short, this option is descriptive, not\n prescriptive. Default: 'row-major'.\n\n options.shape: Array (optional)\n Array shape (dimensions). If a shape is not specified, the function\n attempts to infer a shape based on a provided data source. For example,\n if provided a nested array, the function resolves nested array\n dimensions. If provided a multidimensional array data source, the\n function uses the array's associated shape. For most use cases, such\n inference suffices. For the remaining use cases, specifying a shape is\n necessary. For example, provide a shape to create a multidimensional\n array view over a linear data buffer, ignoring any existing shape meta\n data associated with a provided data source.\n\n options.flatten: boolean (optional)\n Boolean indicating whether to automatically flatten generic array data\n sources. If an array shape is not specified, the shape is inferred from\n the dimensions of nested arrays prior to flattening. If a use case\n requires partial flattening, partially flatten prior to invoking this\n function and set the option value to `false` to prevent further\n flattening during invocation. Default: true.\n\n options.copy: boolean (optional)\n Boolean indicating whether to (shallow) copy source data to a new data\n buffer. The function does *not* perform a deep copy. To prevent\n undesired shared changes in state for generic arrays containing objects,\n perform a deep copy prior to invoking this function. Default: false.\n\n options.ndmin: integer (optional)\n Specifies the minimum number of dimensions. If an array shape has fewer\n dimensions than required by `ndmin`, the function prepends singleton\n dimensions to the array shape in order to satisfy the dimensions\n requirement. Default: 0.\n\n options.casting: string (optional)\n Specifies the casting rule used to determine acceptable casts. The\n option may be one of the following values:\n\n - 'none': only allow casting between identical types.\n - 'equiv': allow casting between identical and byte swapped types.\n - 'safe': only allow \"safe\" casts.\n - 'mostly-safe': allow \"safe casts\" and, for floating-point data types,\n downcasts.\n - 'same-kind': allow \"safe\" casts and casts within the same kind (e.g.,\n between signed integers or between floats).\n - 'unsafe': allow casting between all types (including between integers\n and floats).\n\n Default: 'safe'.\n\n options.codegen: boolean (optional)\n Boolean indicating whether to use code generation. Code generation can\n boost performance, but may be problematic in browser contexts enforcing\n a strict content security policy (CSP). Default: true.\n\n options.mode: string (optional)\n Specifies how to handle indices which exceed array dimensions. The\n option may be one of the following values:\n\n - 'throw': an ndarray instance throws an error when an index exceeds\n array dimensions.\n - 'normalize': an ndarray instance normalizes negative indices and\n throws an error when an index exceeds array dimensions.\n - 'wrap': an ndarray instance wraps around indices exceeding array\n dimensions using modulo arithmetic.\n - 'clamp', an ndarray instance sets an index exceeding array dimensions\n to either `0` (minimum index) or the maximum index.\n\n Default: 'throw'.\n\n options.submode: Array (optional)\n Specifies how to handle subscripts which exceed array dimensions. If a\n mode for a corresponding dimension is equal to\n\n - 'throw': an ndarray instance throws an error when a subscript exceeds\n array dimensions.\n - 'normalize': an ndarray instance normalizes negative subscripts and\n throws an error when a subscript exceeds array dimensions.\n - 'wrap': an ndarray instance wraps around subscripts exceeding array\n dimensions using modulo arithmetic.\n - 'clamp': an ndarray instance sets a subscript exceeding array\n dimensions to either `0` (minimum index) or the maximum index.\n\n If the number of modes is fewer than the number of dimensions, the\n function recycles modes using modulo arithmetic.\n\n Default: [ options.mode ].\n\n options.readonly: boolean (optional)\n Boolean indicating whether an array should be read-only. Default: false.\n\n Returns\n -------\n out: ndarray\n Multidimensional array.\n\n Examples\n --------\n // Create a 2x2 matrix:\n > var arr = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] )\n \n\n // Get an element using subscripts:\n > var v = arr.get( 1, 1 )\n 4.0\n\n // Get an element using a linear index:\n > v = arr.iget( 3 )\n 4.0\n\n // Set an element using subscripts:\n > arr.set( 1, 1, 40.0 );\n > arr.get( 1, 1 )\n 40.0\n\n // Set an element using a linear index:\n > arr.iset( 3, 99.0 );\n > arr.get( 1, 1 )\n 99.0\n\n See Also\n --------\n ndarray\n","array2buffer":"\narray2buffer( arr )\n Allocates a buffer using an octet array.\n\n Parameters\n ----------\n arr: Array\n Array (or array-like object) of octets from which to copy.\n\n Returns\n -------\n out: Buffer\n Buffer instance.\n\n Examples\n --------\n > var buf = array2buffer( [ 1, 2, 3, 4 ] )\n [ 1, 2, 3, 4 ]\n\n See Also\n --------\n Buffer, arraybuffer2buffer, copyBuffer, string2buffer\n","array2fancy":"\narray2fancy( x[, options] )\n Converts an array to an object supporting fancy indexing.\n\n An array supporting fancy indexing is an array which supports slicing via\n indexing expressions for both retrieval and assignment.\n\n A fancy array shares the *same* data as the provided input array. Hence, any\n mutations to the returned array will affect the underlying input array and\n vice versa.\n\n For operations returning a new array (e.g., when slicing or invoking an\n instance method), a fancy array returns a new fancy array having the same\n configuration as specified by provided options.\n\n A fancy array supports indexing using positive and negative integers (both\n numeric literals and strings), Slice instances, subsequence expressions,\n mask arrays, boolean arrays, and integer arrays.\n\n A fancy array supports all properties and methods of the input array, and,\n thus, a fancy array can be consumed by any API which supports array-like\n objects.\n\n Indexing expressions provide a convenient and powerful means for creating\n and operating on array views; however, their use does entail a performance\n cost. Indexing expressions are best suited for interactive use (e.g., in the\n REPL) and scripting. For performance critical applications, prefer\n equivalent functional APIs supporting array-like objects.\n\n Fancy arrays support broadcasting in which assigned scalars and single-\n element arrays are repeated (without additional memory allocation) to match\n the length of a target array instance.\n\n Fancy array broadcasting follows the same rules as for ndarrays.\n\n Consequently, when assigning arrays to slices, the array on the right-hand-\n side must be broadcast-compatible with number of elements in the slice.\n\n Fancy arrays support (mostly) safe casts (i.e., any cast which can be\n performed without overflow or loss of precision, with the exception of\n floating-point arrays which are also allowed to downcast from higher\n precision to lower precision).\n\n When attempting to perform an unsafe cast, fancy arrays will raise an\n exception.\n\n When assigning a real-valued scalar to a complex number array (e.g.,\n Complex128Array or Complex64Array), a fancy array will cast the real-valued\n scalar to a complex number argument having an imaginary component equal to\n zero.\n\n In older JavaScript environments which do not support Proxy objects, the use\n of indexing expressions is not supported.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n options: Object (optional)\n Function options.\n\n options.strict: boolean (optional)\n Boolean indicating whether to enforce strict bounds checking. Default:\n false.\n\n options.cache: Object (optional)\n Cache for resolving array index objects. Must have a 'get' method which\n accepts a single argument: a string identifier associated with an array\n index. If an array index associated with a provided identifier exists,\n the 'get' method should return an object having the following\n properties:\n\n - data: the underlying index array.\n - type: the index type. Must be either 'mask', 'bool', or 'int'.\n - dtype: the data type of the underlying array.\n\n If an array index is not associated with a provided identifier, the\n 'get' method should return `null`.\n\n Default: `ArrayIndex`.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Output array supporting fancy indexing.\n\n Examples\n --------\n > var y = array2fancy( [ 1, 2, 3, 4 ] );\n > y[ '1::2' ]\n [ 2, 4 ]\n > y[ '::-1' ]\n [ 4, 3, 2, 1 ]\n\n\narray2fancy.factory( [options] )\n Returns a function for converting an array to an object supporting fancy\n indexing.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.strict: boolean (optional)\n Boolean indicating whether to enforce strict bounds checking by default.\n Default: false.\n\n options.cache: Object (optional)\n Cache for resolving array index objects. Must have a 'get' method which\n accepts a single argument: a string identifier associated with an array\n index. If an array index associated with a provided identifier exists,\n the 'get' method should return an object having the following\n properties:\n\n - data: the underlying index array.\n - type: the index type. Must be either 'mask', 'bool', or 'int'.\n - dtype: the data type of the underlying array.\n\n If an array index is not associated with a provided identifier, the\n 'get' method should return `null`.\n\n Default: `ArrayIndex`.\n\n Returns\n -------\n fcn: Function\n Function for converting an array to an object supporting fancy indexing.\n\n Examples\n --------\n > var f = array2fancy.factory();\n > var y = f( [ 1, 2, 3, 4 ] );\n > y[ '1::2' ]\n [ 2, 4 ]\n > y[ '::-1' ]\n [ 4, 3, 2, 1 ]\n\n\narray2fancy.idx( x[, options] )\n Wraps a provided array as an array index object.\n\n For documentation and usage, see `ArrayIndex`.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n options: Object (optional)\n Function options.\n\n options.persist: boolean (optional)\n Boolean indicating whether to continue persisting an index object after\n first usage. Default: false.\n\n Returns\n -------\n out: ArrayIndex\n ArrayIndex instance.\n\n Examples\n --------\n > var idx = array2fancy.idx( [ 1, 2, 3, 4 ] );\n\n See Also\n --------\n aslice, FancyArray\n","array2fancy.factory":"\narray2fancy.factory( [options] )\n Returns a function for converting an array to an object supporting fancy\n indexing.\n\n Parameters\n ----------\n options: Object (optional)\n Function options.\n\n options.strict: boolean (optional)\n Boolean indicating whether to enforce strict bounds checking by default.\n Default: false.\n\n options.cache: Object (optional)\n Cache for resolving array index objects. Must have a 'get' method which\n accepts a single argument: a string identifier associated with an array\n index. If an array index associated with a provided identifier exists,\n the 'get' method should return an object having the following\n properties:\n\n - data: the underlying index array.\n - type: the index type. Must be either 'mask', 'bool', or 'int'.\n - dtype: the data type of the underlying array.\n\n If an array index is not associated with a provided identifier, the\n 'get' method should return `null`.\n\n Default: `ArrayIndex`.\n\n Returns\n -------\n fcn: Function\n Function for converting an array to an object supporting fancy indexing.\n\n Examples\n --------\n > var f = array2fancy.factory();\n > var y = f( [ 1, 2, 3, 4 ] );\n > y[ '1::2' ]\n [ 2, 4 ]\n > y[ '::-1' ]\n [ 4, 3, 2, 1 ]","array2fancy.idx":"\narray2fancy.idx( x[, options] )\n Wraps a provided array as an array index object.\n\n For documentation and usage, see `ArrayIndex`.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n options: Object (optional)\n Function options.\n\n options.persist: boolean (optional)\n Boolean indicating whether to continue persisting an index object after\n first usage. Default: false.\n\n Returns\n -------\n out: ArrayIndex\n ArrayIndex instance.\n\n Examples\n --------\n > var idx = array2fancy.idx( [ 1, 2, 3, 4 ] );\n\n See Also\n --------\n aslice, FancyArray","array2iterator":"\narray2iterator( src[, mapFcn[, thisArg]] )\n Returns an iterator which iterates over the elements of an array-like\n object.\n\n When invoked, an input function is provided three arguments:\n\n - value: iterated value.\n - index: iterated value index.\n - src: source array-like object.\n\n If an environment supports Symbol.iterator, the returned iterator is\n iterable.\n\n If an environment supports Symbol.iterator, the function explicitly does not\n invoke an array's `@@iterator` method, regardless of whether this method is\n defined. To convert an array to an implementation defined iterator, invoke\n this method directly.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Array-like object from which to create the iterator.\n\n mapFcn: Function (optional)\n Function to invoke for each iterated value.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n iterator: Object\n Iterator.\n\n iterator.next(): Function\n Returns an iterator protocol-compliant object containing the next\n iterated value (if one exists) and a boolean flag indicating whether the\n iterator is finished.\n\n iterator.return( [value] ): Function\n Finishes an iterator and returns a provided value.\n\n Examples\n --------\n > var it = array2iterator( [ 1, 2, 3, 4 ] );\n > var v = it.next().value\n 1\n > v = it.next().value\n 2\n\n See Also\n --------\n iterator2array, circarray2iterator, array2iteratorRight, stridedarray2iterator\n","array2iteratorRight":"\narray2iteratorRight( src[, mapFcn[, thisArg]] )\n Returns an iterator which iterates from right to left over the elements of\n an array-like object.\n\n When invoked, an input function is provided three arguments:\n\n - value: iterated value.\n - index: iterated value index.\n - src: source array-like object.\n\n If an environment supports Symbol.iterator, the returned iterator is\n iterable.\n\n If an environment supports Symbol.iterator, the function explicitly does not\n invoke an array's `@@iterator` method, regardless of whether this method is\n defined. To convert an array to an implementation defined iterator, invoke\n this method directly.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Array-like object from which to create the iterator.\n\n mapFcn: Function (optional)\n Function to invoke for each iterated value.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n iterator: Object\n Iterator.\n\n iterator.next(): Function\n Returns an iterator protocol-compliant object containing the next\n iterated value (if one exists) and a boolean flag indicating whether the\n iterator is finished.\n\n iterator.return( [value] ): Function\n Finishes an iterator and returns a provided value.\n\n Examples\n --------\n > var it = array2iteratorRight( [ 1, 2, 3, 4 ] );\n > var v = it.next().value\n 4\n > v = it.next().value\n 3\n\n See Also\n --------\n iterator2array, array2iterator\n","ArrayBuffer":"\nArrayBuffer( size )\n Returns an array buffer having a specified number of bytes.\n\n Buffer contents are initialized to 0.\n\n Parameters\n ----------\n size: integer\n Number of bytes.\n\n Returns\n -------\n out: ArrayBuffer\n An array buffer.\n\n Examples\n --------\n > var buf = new ArrayBuffer( 5 )\n \n\n\nArrayBuffer.length\n Number of input arguments the constructor accepts.\n\n Examples\n --------\n > ArrayBuffer.length\n 1\n\n\nArrayBuffer.isView( arr )\n Returns a boolean indicating if provided an array buffer view.\n\n Parameters\n ----------\n arr: any\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating if an input argument is a buffer view.\n\n Examples\n --------\n > var arr = new Float64Array( 10 );\n > ArrayBuffer.isView( arr )\n true\n\n\nArrayBuffer.prototype.byteLength\n Read-only property which returns the length (in bytes) of the array buffer.\n\n Examples\n --------\n > var buf = new ArrayBuffer( 5 );\n > buf.byteLength\n 5\n\n\nArrayBuffer.prototype.slice( [start[, end]] )\n Copies the bytes of an array buffer to a new array buffer.\n\n Parameters\n ----------\n start: integer (optional)\n Index at which to start copying buffer contents (inclusive). If\n negative, the index is relative to the end of the buffer.\n\n end: integer (optional)\n Index at which to stop copying buffer contents (exclusive). If negative,\n the index is relative to the end of the buffer.\n\n Returns\n -------\n out: ArrayBuffer\n A new array buffer whose contents have been copied from the calling\n array buffer.\n\n Examples\n --------\n > var b1 = new ArrayBuffer( 10 );\n > var b2 = b1.slice( 2, 6 );\n > var bool = ( b1 === b2 )\n false\n > b2.byteLength\n 4\n\n See Also\n --------\n Buffer, Float32Array, Float64Array, Int16Array, Int32Array, Int8Array, SharedArrayBuffer, Uint16Array, Uint32Array, Uint8Array, Uint8ClampedArray\n","ArrayBuffer.length":"\nArrayBuffer.length\n Number of input arguments the constructor accepts.\n\n Examples\n --------\n > ArrayBuffer.length\n 1","ArrayBuffer.isView":"\nArrayBuffer.isView( arr )\n Returns a boolean indicating if provided an array buffer view.\n\n Parameters\n ----------\n arr: any\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating if an input argument is a buffer view.\n\n Examples\n --------\n > var arr = new Float64Array( 10 );\n > ArrayBuffer.isView( arr )\n true","ArrayBuffer.prototype.byteLength":"\nArrayBuffer.prototype.byteLength\n Read-only property which returns the length (in bytes) of the array buffer.\n\n Examples\n --------\n > var buf = new ArrayBuffer( 5 );\n > buf.byteLength\n 5","ArrayBuffer.prototype.slice":"\nArrayBuffer.prototype.slice( [start[, end]] )\n Copies the bytes of an array buffer to a new array buffer.\n\n Parameters\n ----------\n start: integer (optional)\n Index at which to start copying buffer contents (inclusive). If\n negative, the index is relative to the end of the buffer.\n\n end: integer (optional)\n Index at which to stop copying buffer contents (exclusive). If negative,\n the index is relative to the end of the buffer.\n\n Returns\n -------\n out: ArrayBuffer\n A new array buffer whose contents have been copied from the calling\n array buffer.\n\n Examples\n --------\n > var b1 = new ArrayBuffer( 10 );\n > var b2 = b1.slice( 2, 6 );\n > var bool = ( b1 === b2 )\n false\n > b2.byteLength\n 4\n\n See Also\n --------\n Buffer, Float32Array, Float64Array, Int16Array, Int32Array, Int8Array, SharedArrayBuffer, Uint16Array, Uint32Array, Uint8Array, Uint8ClampedArray","arraybuffer2buffer":"\narraybuffer2buffer( buf[, byteOffset[, length]] )\n Allocates a buffer from an ArrayBuffer.\n\n The behavior of this function varies across Node.js versions due to changes\n in the underlying Node.js APIs:\n\n - <3.0.0: the function copies ArrayBuffer bytes to a new Buffer instance.\n - >=3.0.0 and <5.10.0: if provided a byte offset, the function copies\n ArrayBuffer bytes to a new Buffer instance; otherwise, the function\n returns a view of an ArrayBuffer without copying the underlying memory.\n - <6.0.0: if provided an empty ArrayBuffer, the function returns an empty\n Buffer which is not an ArrayBuffer view.\n - >=6.0.0: the function returns a view of an ArrayBuffer without copying\n the underlying memory.\n\n Parameters\n ----------\n buf: ArrayBuffer\n Input array buffer.\n\n byteOffset: integer (optional)\n Index offset specifying the location of the first byte.\n\n length: integer (optional)\n Number of bytes to expose from the underlying ArrayBuffer.\n\n Returns\n -------\n out: Buffer\n Buffer instance.\n\n Examples\n --------\n > var ab = new ArrayBuffer( 10 )\n \n > var buf = arraybuffer2buffer( ab )\n \n > var len = buf.length\n 10\n > buf = arraybuffer2buffer( ab, 2, 6 )\n \n > len = buf.length\n 6\n\n See Also\n --------\n Buffer, array2buffer, copyBuffer, string2buffer\n","arrayCtors":"\narrayCtors( dtype )\n Returns an array constructor.\n\n The function returns constructors for the following data types:\n\n - float32: single-precision floating-point numbers.\n - float64: double-precision floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - complex128: double-precision complex floating-point numbers.\n - bool: boolean values.\n - generic: values of any type.\n - int16: signed 16-bit integers.\n - int32: signed 32-bit integers.\n - int8: signed 8-bit integers.\n - uint16: unsigned 16-bit integers.\n - uint32: unsigned 32-bit integers.\n - uint8: unsigned 8-bit integers.\n - uint8c: unsigned clamped 8-bit integers.\n\n Parameters\n ----------\n dtype: string\n Data type.\n\n Returns\n -------\n out: Function|null\n Constructor.\n\n Examples\n --------\n > var ctor = arrayCtors( 'float64' )\n \n > ctor = arrayCtors( 'float' )\n null\n\n See Also\n --------\n typedarrayCtors\n","arrayDataType":"\narrayDataType( array )\n Returns the data type of an array.\n\n If provided an argument having an unknown or unsupported type, the function\n returns `null`.\n\n Parameters\n ----------\n array: any\n Input value.\n\n Returns\n -------\n out: string|null\n Data type.\n\n Examples\n --------\n > var arr = new Float64Array( 10 );\n > var dt = arrayDataType( arr )\n 'float64'\n > dt = arrayDataType( 'beep' )\n null\n\n See Also\n --------\n arrayDataTypes\n","arrayDataTypes":"\narrayDataTypes( [kind] )\n Returns a list of array data types.\n\n When not provided a data type \"kind\", the function returns an array\n containing the following data types:\n\n - float32: single-precision floating-point numbers.\n - float64: double-precision floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - complex128: double-precision complex floating-point numbers.\n - bool: boolean values.\n - generic: values of any type.\n - int16: signed 16-bit integers.\n - int32: signed 32-bit integers.\n - int8: signed 8-bit integers.\n - uint16: unsigned 16-bit integers.\n - uint32: unsigned 32-bit integers.\n - uint8: unsigned 8-bit integers.\n - uint8c: unsigned clamped 8-bit integers.\n\n The function supports the following data type \"kinds\":\n\n - floating_point: floating-point data types.\n - real_floating_point: real-valued floating-point data types.\n - complex_floating_point: complex-valued floating-point data types.\n - boolean: boolean data types.\n - integer: integer data types.\n - signed_integer: signed integer data types.\n - unsigned_integer: unsigned integer data types.\n - real: real-valued data types.\n - numeric: numeric data types.\n - typed: typed data types.\n - integer_index: integer index data types.\n - boolean_index: boolean index data types.\n - mask_index: mask index data types.\n - typed_index: typed index data types.\n - index: index data types.\n - all: all data types.\n\n Additionally, the function supports extending the \"kinds\" listed above by\n appending a '_and_generic' suffix to the kind name (e.g., real_and_generic).\n\n Parameters\n ----------\n kind: string (optional)\n Data type kind.\n\n Returns\n -------\n out: Array\n List of array data types.\n\n Examples\n --------\n > var out = arrayDataTypes()\n [...]\n > out = arrayDataTypes( 'floating_point' )\n [...]\n > out = arrayDataTypes( 'floating_point_and_generic' )\n [...]\n\n See Also\n --------\n typedarrayDataTypes, ndarrayDataTypes\n","ArrayIndex":"\nArrayIndex( x[, options] )\n Wraps a provided array as an array index object.\n\n Array index instances have no explicit functionality; however, they are used\n by \"fancy\" arrays for element retrieval and assignment.\n\n By default, an instance is invalidated and removed from an internal cache\n immediately after a consumer resolves the underlying data associated with an\n instance using the `get` static method. Immediate invalidation and cache\n removal ensures that references to the underlying array are not the source\n of memory leaks.\n\n Because instances leverage an internal cache implementing the Singleton\n pattern, one must be sure to use the same constructor as consumers. If one\n uses a different constructor, the consumer will *not* be able to resolve the\n original wrapped array, as the consumer will attempt to resolve an instance\n in the wrong internal cache.\n\n Because non-persisted instances are freed after first use, in order to avoid\n holding onto memory and to allow garbage collection, one should avoid\n scenarios in which an instance is never used.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n options: Object (optional)\n Function options.\n\n options.persist: boolean (optional)\n Boolean indicating whether to continue persisting an index object after\n first usage. Default: false.\n\n Returns\n -------\n out: ArrayIndex\n ArrayIndex instance.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n\n\nArrayIndex.free( id )\n Frees the instance associated with a provided identifier.\n\n Parameters\n ----------\n id: string\n Instance identifier.\n\n Returns\n -------\n out: boolean\n Boolean indicating whether an instance was successfully freed.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > ArrayIndex.free( idx.id )\n \n\n\nArrayIndex.get( id )\n Returns the array associated with the instance having a provided identifier.\n\n Parameters\n ----------\n id: string\n Instance identifier.\n\n Returns\n -------\n out: Object\n Object containing array data.\n\n out.data: Array|TypedArray|Object\n The underlying array associated with the provided identifier.\n\n out.type: string\n The type of array index.\n\n out.dtype: string\n The data type of the underlying array.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > ArrayIndex.get( idx.id )\n {...}\n\n\nArrayIndex.prototype.data\n Read-only property returning the underlying index array.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Array data.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.data\n [ 1, 2, 3, 4 ]\n\n\nArrayIndex.prototype.dtype\n Read-only property returning the underlying data type of the index array.\n\n Returns\n -------\n out: string\n Array data type.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.dtype\n 'generic'\n\n\nArrayIndex.prototype.id\n Read-only property returning the unique identifier associated with an\n instance.\n\n Returns\n -------\n out: string\n String identifier.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.id\n \n\n\nArrayIndex.prototype.isCached\n Read-only property returning a boolean indicating whether an array index is\n actively cached.\n\n Returns\n -------\n out: boolean\n Boolean indicating whether an array index is actively cached.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.isCached\n true\n\n\nArrayIndex.prototype.type\n Read-only property returning the array index type.\n\n Returns\n -------\n out: string\n Array index type.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.type\n \n\n\nArrayIndex.prototype.toString()\n Serializes an instance as a string.\n\n Returns\n -------\n str: string\n Serialized string.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.toString()\n \n\n\nArrayIndex.prototype.toJSON()\n Serializes an instance as a JSON object.\n\n Returns\n -------\n obj: Object\n JSON object.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.toJSON()\n { 'type': 'ArrayIndex', 'data': [ 1, 2, 3, 4 ] }\n\n See Also\n --------\n array2fancy\n","ArrayIndex.free":"\nArrayIndex.free( id )\n Frees the instance associated with a provided identifier.\n\n Parameters\n ----------\n id: string\n Instance identifier.\n\n Returns\n -------\n out: boolean\n Boolean indicating whether an instance was successfully freed.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > ArrayIndex.free( idx.id )\n ","ArrayIndex.get":"\nArrayIndex.get( id )\n Returns the array associated with the instance having a provided identifier.\n\n Parameters\n ----------\n id: string\n Instance identifier.\n\n Returns\n -------\n out: Object\n Object containing array data.\n\n out.data: Array|TypedArray|Object\n The underlying array associated with the provided identifier.\n\n out.type: string\n The type of array index.\n\n out.dtype: string\n The data type of the underlying array.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > ArrayIndex.get( idx.id )\n {...}","ArrayIndex.prototype.data":"\nArrayIndex.prototype.data\n Read-only property returning the underlying index array.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Array data.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.data\n [ 1, 2, 3, 4 ]","ArrayIndex.prototype.dtype":"\nArrayIndex.prototype.dtype\n Read-only property returning the underlying data type of the index array.\n\n Returns\n -------\n out: string\n Array data type.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.dtype\n 'generic'","ArrayIndex.prototype.id":"\nArrayIndex.prototype.id\n Read-only property returning the unique identifier associated with an\n instance.\n\n Returns\n -------\n out: string\n String identifier.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.id\n ","ArrayIndex.prototype.isCached":"\nArrayIndex.prototype.isCached\n Read-only property returning a boolean indicating whether an array index is\n actively cached.\n\n Returns\n -------\n out: boolean\n Boolean indicating whether an array index is actively cached.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.isCached\n true","ArrayIndex.prototype.type":"\nArrayIndex.prototype.type\n Read-only property returning the array index type.\n\n Returns\n -------\n out: string\n Array index type.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.type\n ","ArrayIndex.prototype.toString":"\nArrayIndex.prototype.toString()\n Serializes an instance as a string.\n\n Returns\n -------\n str: string\n Serialized string.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.toString()\n ","ArrayIndex.prototype.toJSON":"\nArrayIndex.prototype.toJSON()\n Serializes an instance as a JSON object.\n\n Returns\n -------\n obj: Object\n JSON object.\n\n Examples\n --------\n > var idx = new ArrayIndex( [ 1, 2, 3, 4 ] );\n > idx.toJSON()\n { 'type': 'ArrayIndex', 'data': [ 1, 2, 3, 4 ] }\n\n See Also\n --------\n array2fancy","arrayMinDataType":"\narrayMinDataType( value )\n Returns the minimum array data type of the closest \"kind\" necessary for\n storing a provided scalar value.\n\n The function does *not* provide precision guarantees for non-integer-valued\n numbers. In other words, the function returns the smallest possible\n floating-point (i.e., inexact) data type for storing numbers having\n decimals.\n\n Parameters\n ----------\n value: any\n Scalar value.\n\n Returns\n -------\n dt: string\n Array data type.\n\n Examples\n --------\n > var dt = arrayMinDataType( 3.141592653589793 )\n 'float32'\n > dt = arrayMinDataType( 3 )\n 'uint8'\n > dt = arrayMinDataType( -3 )\n 'int8'\n > dt = arrayMinDataType( '-3' )\n 'generic'\n\n See Also\n --------\n arrayDataTypes, arrayPromotionRules, arraySafeCasts\n","arrayMostlySafeCasts":"\narrayMostlySafeCasts( [dtype] )\n Returns a list of array data types to which a provided array data type can\n be safely cast and, for floating-point data types, can be downcast.\n\n If not provided an array data type, the function returns a casting table.\n\n If provided an unrecognized array data type, the function returns `null`.\n\n Parameters\n ----------\n dtype: any (optional)\n Array data type value.\n\n Returns\n -------\n out: Object|Array|null\n Array data types to which a data type can be cast.\n\n Examples\n --------\n > var out = arrayMostlySafeCasts( 'float32' )\n \n\n See Also\n --------\n convertArray, convertArraySame, arrayDataTypes, arraySafeCasts, arraySameKindCasts, ndarrayMostlySafeCasts\n","arrayNextDataType":"\narrayNextDataType( [dtype] )\n Returns the next larger array data type of the same kind.\n\n If not provided a data type, the function returns a table.\n\n If a data type does not have a next larger data type or the next larger type\n is not supported, the function returns `-1`.\n\n If provided an unrecognized data type, the function returns `null`.\n\n Parameters\n ----------\n dtype: string (optional)\n Array data type.\n\n Returns\n -------\n out: Object|string|integer|null\n Next larger type(s).\n\n Examples\n --------\n > var out = arrayNextDataType( 'float32' )\n 'float64'\n\n See Also\n --------\n arrayDataType, arrayDataTypes\n","arrayPromotionRules":"\narrayPromotionRules( [dtype1, dtype2] )\n Returns the array data type with the smallest size and closest \"kind\" to\n which array data types can be safely cast.\n\n If not provided data types, the function returns a type promotion table.\n\n If a data type to which data types can be safely cast does *not* exist (or\n is not supported), the function returns `-1`.\n\n If provided an unrecognized data type, the function returns `null`.\n\n Parameters\n ----------\n dtype1: any (optional)\n Array data type.\n\n dtype2: any (optional)\n Array data type.\n\n Returns\n -------\n out: Object|string|integer|null\n Promotion rule(s).\n\n Examples\n --------\n > var out = arrayPromotionRules( 'float32', 'int32' )\n 'float64'\n\n See Also\n --------\n arrayDataTypes, arraySafeCasts, ndarrayPromotionRules\n","arraySafeCasts":"\narraySafeCasts( [dtype] )\n Returns a list of array data types to which a provided array data type can\n be safely cast.\n\n If not provided an array data type, the function returns a casting table.\n\n If provided an unrecognized array data type, the function returns `null`.\n\n Parameters\n ----------\n dtype: any (optional)\n Array data type.\n\n Returns\n -------\n out: Object|Array|null\n Array data types to which a data type can be safely cast.\n\n Examples\n --------\n > var out = arraySafeCasts( 'float32' )\n \n\n See Also\n --------\n convertArray, convertArraySame, arrayDataTypes, arrayMostlySafeCasts, arraySameKindCasts, ndarraySafeCasts\n","arraySameKindCasts":"\narraySameKindCasts( [dtype] )\n Returns a list of array data types to which a provided array data type can\n be safely cast or cast within the same \"kind\".\n\n If not provided an array data type, the function returns a casting table.\n\n If provided an unrecognized array data type, the function returns `null`.\n\n Parameters\n ----------\n dtype: any (optional)\n Array data type.\n\n Returns\n -------\n out: Object|Array|null\n Array data types to which a data type can be safely cast or cast within\n the same \"kind\".\n\n Examples\n --------\n > var out = arraySameKindCasts( 'float32' )\n \n\n See Also\n --------\n convertArray, convertArraySame, arrayDataTypes, arraySafeCasts, ndarraySameKindCasts\n","arrayShape":"\narrayShape( arr )\n Determines array dimensions.\n\n Parameters\n ----------\n arr: ArrayLikeObject\n Input array.\n\n Returns\n -------\n out: Array\n Array shape.\n\n Examples\n --------\n > var out = arrayShape( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] )\n [ 2, 3 ]\n\n See Also\n --------\n ndarray\n","arrayStream":"\narrayStream( src[, options] )\n Creates a readable stream from an array-like object.\n\n In object mode, `null` is a reserved value. If an array contains `null`\n values (e.g., as a means to encode missing values), the stream will\n prematurely end. Consider an alternative encoding or filter `null` values\n prior to invocation.\n\n In binary mode, if an array contains `undefined` values, the stream will\n emit an error. Consider providing a custom serialization function or\n filtering `undefined` values prior to invocation.\n\n If a serialization function fails to return a string or Buffer, the stream\n emits an error.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Source value.\n\n options: Object (optional)\n Options.\n\n options.objectMode: boolean (optional)\n Specifies whether a stream should operate in \"objectMode\". Default:\n false.\n\n options.encoding: string|null (optional)\n Specifies how Buffer objects should be decoded to strings. Default:\n null.\n\n options.highWaterMark: integer (optional)\n Specifies the maximum number of bytes to store in an internal buffer\n before pausing the stream.\n\n options.sep: string (optional)\n Separator used to join streamed data. This option is only applicable\n when a stream is not in \"objectMode\". Default: '\\n'.\n\n options.serialize: Function (optional)\n Serialization function. The default behavior is to serialize streamed\n values as JSON strings. This option is only applicable when a stream is\n not in \"objectMode\".\n\n options.dir: integer (optional)\n Iteration direction. If set to `-1`, a stream iterates over elements\n from right-to-left. Default: 1.\n\n Returns\n -------\n stream: ReadableStream\n Readable stream.\n\n Examples\n --------\n > function fcn( chunk ) { console.log( chunk.toString() ); };\n > var s = arrayStream( [ 1, 2, 3 ] );\n > var o = inspectSinkStream( fcn );\n > s.pipe( o );\n\n\narrayStream.factory( [options] )\n Returns a function for creating readable streams from array-like objects.\n\n Parameters\n ----------\n options: Object (optional)\n Options.\n\n options.objectMode: boolean (optional)\n Specifies whether a stream should operate in \"objectMode\". Default:\n false.\n\n options.encoding: string|null (optional)\n Specifies how Buffer objects should be decoded to strings. Default:\n null.\n\n options.highWaterMark: integer (optional)\n Specifies the maximum number of bytes to store in an internal buffer\n before pausing streaming.\n\n options.sep: string (optional)\n Separator used to join streamed data. This option is only applicable\n when a stream is not in \"objectMode\". Default: '\\n'.\n\n options.serialize: Function (optional)\n Serialization function. The default behavior is to serialize streamed\n values as JSON strings. This option is only applicable when a stream is\n not in \"objectMode\".\n\n options.dir: integer (optional)\n Iteration direction. If set to `-1`, a stream iterates over elements\n from right-to-left. Default: 1.\n\n Returns\n -------\n fcn: Function\n Function for creating readable streams.\n\n Examples\n --------\n > var opts = { 'objectMode': true, 'highWaterMark': 64 };\n > var createStream = arrayStream.factory( opts );\n\n\narrayStream.objectMode( src[, options] )\n Returns an \"objectMode\" readable stream from an array-like object.\n\n In object mode, `null` is a reserved value. If an array contains `null`\n values (e.g., as a means to encode missing values), the stream will\n prematurely end. Consider an alternative encoding or filter `null` values\n prior to invocation.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Source value.\n\n options: Object (optional)\n Options.\n\n options.encoding: string|null (optional)\n Specifies how Buffer objects should be decoded to strings. Default:\n null.\n\n options.highWaterMark: integer (optional)\n Specifies the maximum number of objects to store in an internal buffer\n before pausing streaming.\n\n options.dir: integer (optional)\n Iteration direction. If set to `-1`, a stream iterates over elements\n from right-to-left. Default: 1.\n\n Returns\n -------\n stream: ReadableStream\n Readable stream operating in \"objectMode\".\n\n Examples\n --------\n > function fcn( v ) { console.log( v ); };\n > var s = arrayStream.objectMode( [ 1, 2, 3 ] );\n > var o = inspectSinkStream.objectMode( fcn );\n > s.pipe( o );\n\n See Also\n --------\n circularArrayStream, iteratorStream, stridedArrayStream\n","arrayStream.factory":"\narrayStream.factory( [options] )\n Returns a function for creating readable streams from array-like objects.\n\n Parameters\n ----------\n options: Object (optional)\n Options.\n\n options.objectMode: boolean (optional)\n Specifies whether a stream should operate in \"objectMode\". Default:\n false.\n\n options.encoding: string|null (optional)\n Specifies how Buffer objects should be decoded to strings. Default:\n null.\n\n options.highWaterMark: integer (optional)\n Specifies the maximum number of bytes to store in an internal buffer\n before pausing streaming.\n\n options.sep: string (optional)\n Separator used to join streamed data. This option is only applicable\n when a stream is not in \"objectMode\". Default: '\\n'.\n\n options.serialize: Function (optional)\n Serialization function. The default behavior is to serialize streamed\n values as JSON strings. This option is only applicable when a stream is\n not in \"objectMode\".\n\n options.dir: integer (optional)\n Iteration direction. If set to `-1`, a stream iterates over elements\n from right-to-left. Default: 1.\n\n Returns\n -------\n fcn: Function\n Function for creating readable streams.\n\n Examples\n --------\n > var opts = { 'objectMode': true, 'highWaterMark': 64 };\n > var createStream = arrayStream.factory( opts );","arrayStream.objectMode":"\narrayStream.objectMode( src[, options] )\n Returns an \"objectMode\" readable stream from an array-like object.\n\n In object mode, `null` is a reserved value. If an array contains `null`\n values (e.g., as a means to encode missing values), the stream will\n prematurely end. Consider an alternative encoding or filter `null` values\n prior to invocation.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Source value.\n\n options: Object (optional)\n Options.\n\n options.encoding: string|null (optional)\n Specifies how Buffer objects should be decoded to strings. Default:\n null.\n\n options.highWaterMark: integer (optional)\n Specifies the maximum number of objects to store in an internal buffer\n before pausing streaming.\n\n options.dir: integer (optional)\n Iteration direction. If set to `-1`, a stream iterates over elements\n from right-to-left. Default: 1.\n\n Returns\n -------\n stream: ReadableStream\n Readable stream operating in \"objectMode\".\n\n Examples\n --------\n > function fcn( v ) { console.log( v ); };\n > var s = arrayStream.objectMode( [ 1, 2, 3 ] );\n > var o = inspectSinkStream.objectMode( fcn );\n > s.pipe( o );\n\n See Also\n --------\n circularArrayStream, iteratorStream, stridedArrayStream","arrayview2iterator":"\narrayview2iterator( src[, begin[, end]][, mapFcn[, thisArg]] )\n Returns an iterator which iterates over the elements of an array-like object\n view.\n\n When invoked, an input function is provided four arguments:\n\n - value: iterated value.\n - index: iterated value index.\n - n: iteration count (zero-based).\n - src: source array-like object.\n\n If an environment supports Symbol.iterator, the returned iterator is\n iterable.\n\n If an environment supports Symbol.iterator, the function explicitly does not\n invoke an array's `@@iterator` method, regardless of whether this method is\n defined. To convert an array to an implementation defined iterator, invoke\n this method directly.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Array-like object from which to create the iterator.\n\n begin: integer (optional)\n Starting index (inclusive). When negative, determined relative to the\n last element. Default: 0.\n\n end: integer (optional)\n Ending index (non-inclusive). When negative, determined relative to the\n last element. Default: src.length.\n\n mapFcn: Function (optional)\n Function to invoke for each iterated value.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n iterator: Object\n Iterator.\n\n iterator.next(): Function\n Returns an iterator protocol-compliant object containing the next\n iterated value (if one exists) and a boolean flag indicating whether the\n iterator is finished.\n\n iterator.return( [value] ): Function\n Finishes an iterator and returns a provided value.\n\n Examples\n --------\n > var it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3 );\n > var v = it.next().value\n 2\n > v = it.next().value\n 3\n\n See Also\n --------\n iterator2array, array2iterator, stridedarray2iterator, arrayview2iteratorRight\n","arrayview2iteratorRight":"\narrayview2iteratorRight( src[, begin[, end]][, mapFcn[, thisArg]] )\n Returns an iterator which iterates from right to left over the elements of\n an array-like object view.\n\n When invoked, an input function is provided four arguments:\n\n - value: iterated value.\n - index: iterated value index.\n - n: iteration count (zero-based).\n - src: source array-like object.\n\n If an environment supports Symbol.iterator, the returned iterator is\n iterable.\n\n If an environment supports Symbol.iterator, the function explicitly does not\n invoke an array's `@@iterator` method, regardless of whether this method is\n defined. To convert an array to an implementation defined iterator, invoke\n this method directly.\n\n Parameters\n ----------\n src: ArrayLikeObject\n Array-like object from which to create the iterator.\n\n begin: integer (optional)\n Starting index (inclusive). When negative, determined relative to the\n last element. Default: 0.\n\n end: integer (optional)\n Ending index (non-inclusive). When negative, determined relative to the\n last element. Default: src.length.\n\n mapFcn: Function (optional)\n Function to invoke for each iterated value.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n iterator: Object\n Iterator.\n\n iterator.next(): Function\n Returns an iterator protocol-compliant object containing the next\n iterated value (if one exists) and a boolean flag indicating whether the\n iterator is finished.\n\n iterator.return( [value] ): Function\n Finishes an iterator and returns a provided value.\n\n Examples\n --------\n > var it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3 );\n > var v = it.next().value\n 3\n > v = it.next().value\n 2\n\n See Also\n --------\n iterator2array, array2iteratorRight, stridedarray2iterator, arrayview2iterator\n","aslice":"\naslice( x[, start[, end]] )\n Returns a shallow copy of a portion of an array.\n\n If provided an array-like object having a `slice` method, the function\n defers execution to that method and assumes that the method has the\n following signature:\n\n x.slice( start, end )\n\n If provided an array-like object without a `slice` method, the function\n copies input array elements to a new generic array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n start: integer (optional)\n Starting index (inclusive). Default: 0.\n\n end: integer (optional)\n Ending index (exclusive). Default: x.length.\n\n Returns\n -------\n out: Array|TypedArray\n Output array.\n\n Examples\n --------\n > var out = aslice( [ 1, 2, 3, 4 ] )\n [ 1, 2, 3, 4 ]\n > out = aslice( [ 1, 2, 3, 4 ], 1 )\n [ 2, 3, 4 ]\n > out = aslice( [ 1, 2, 3, 4 ], 1, 3 )\n [ 2, 3 ]\n\n See Also\n --------\n atake\n","AsyncIteratorSymbol":"\nAsyncIteratorSymbol\n Async iterator symbol.\n\n This symbol specifies the default async iterator for an object.\n\n The symbol is only supported in ES2018+ environments. For non-supporting\n environments, the value is `null`.\n\n Examples\n --------\n > var s = AsyncIteratorSymbol\n\n See Also\n --------\n Symbol, IteratorSymbol\n","atake":"\natake( x, indices[, options] )\n Takes elements from an array.\n\n If `indices` is an empty array, the function returns an empty array.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n indices: ArrayLikeObject\n List of element indices.\n\n options: Object (optional)\n Function options.\n\n options.mode: string (optional)\n Specifies how to handle an index outside the interval [0, max], where\n `max` is the maximum possible array index. If equal to 'throw', the\n function throws an error. If equal to 'normalize', the function throws\n an error if provided an out-of-bounds normalized index. If equal to\n 'wrap', the function wraps around an index using modulo arithmetic. If\n equal to 'clamp', the function sets an index to either 0 (minimum index)\n or the maximum index. Default: 'normalize'.\n\n Returns\n -------\n out: Array|TypedArray\n Output array.\n\n Examples\n --------\n > var x = [ 1, 2, 3, 4 ];\n > var y = atake( x, [ 1, 3 ] )\n [ 2, 4 ]\n\n See Also\n --------\n aput, aslice\n","azeros":"\nazeros( length[, dtype] )\n Returns a zero-filled array having a specified length.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n The default array data type is `float64`.\n\n Parameters\n ----------\n length: integer\n Array length.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = azeros( 2 )\n [ 0.0, 0.0 ]\n > arr = azeros( 2, 'float32' )\n [ 0.0, 0.0 ]\n\n See Also\n --------\n aempty, afull, anans, aones, azerosLike, ndzeros\n","azerosLike":"\nazerosLike( x[, dtype] )\n Returns a zero-filled array having the same length and data type as a\n provided input array.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var x = new Float64Array( 2 );\n > var y = azerosLike( x )\n [ 0.0, 0.0 ]\n > y = azerosLike( x, 'float32' )\n [ 0.0, 0.0 ]\n\n See Also\n --------\n aemptyLike, afullLike, anansLike, aonesLike, azeros, ndzerosLike\n","azeroTo":"\nazeroTo( n[, dtype] )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from zero.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n The default array data type is `float64`.\n\n If `n` is equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n n: integer\n Number of elements.\n\n dtype: string (optional)\n Data type. Default: 'float64'.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = azeroTo( 2 )\n [ 0.0, 1.0 ]\n > arr = azeroTo( 2, 'float32' )\n [ 0.0, 1.0 ]\n\n See Also\n --------\n aempty, afull, aoneTo, azeroToLike, azeros\n","azeroToLike":"\nazeroToLike( x[, dtype] )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from zero and having the same length and data type as a provided\n input array.\n\n The function supports the following data types:\n\n - float64: double-precision floating-point numbers (IEEE 754).\n - float32: single-precision floating-point numbers (IEEE 754).\n - complex128: double-precision complex floating-point numbers.\n - complex64: single-precision complex floating-point numbers.\n - int32: 32-bit two's complement signed integers.\n - uint32: 32-bit unsigned integers.\n - int16: 16-bit two's complement signed integers.\n - uint16: 16-bit unsigned integers.\n - int8: 8-bit two's complement signed integers.\n - uint8: 8-bit unsigned integers.\n - uint8c: 8-bit unsigned integers clamped to 0-255.\n - generic: generic JavaScript values.\n\n Parameters\n ----------\n x: TypedArray|Array\n Input array.\n\n dtype: string (optional)\n Data type. If not provided, the output array data type is inferred from\n the input array.\n\n Returns\n -------\n out: TypedArray|Array\n Output array.\n\n Examples\n --------\n > var arr = azeroToLike( [ 0, 0 ] )\n [ 0, 1 ]\n > arr = azeroToLike( [ 0, 0 ], 'float32' )\n [ 0.0, 1.0 ]\n\n See Also\n --------\n aemptyLike, afullLike, anansLike, aoneToLike, aonesLike, azeroTo, azerosLike\n","bartlettTest":"\nbartlettTest( ...x[, options] )\n Computes Bartlett’s test for equal variances.\n\n Parameters\n ----------\n x: ...Array\n Measured values.\n\n options: Object (optional)\n Options.\n\n options.alpha: number (optional)\n Number in the interval `[0,1]` giving the significance level of the\n hypothesis test. Default: `0.05`.\n\n options.groups: Array (optional)\n Array of group indicators.\n\n Returns\n -------\n out: Object\n Test result object.\n\n out.alpha: number\n Significance level.\n\n out.rejected: boolean\n Test decision.\n\n out.pValue: number\n p-value of the test.\n\n out.statistic: number\n Value of test statistic.\n\n out.method: string\n Name of test.\n\n out.df: Object\n Degrees of freedom.\n\n out.print: Function\n Function to print formatted output.\n\n Examples\n --------\n // Data from Hollander & Wolfe (1973), p. 116:\n > var x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\n > var y = [ 3.8, 2.7, 4.0, 2.4 ];\n > var z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\n\n > var out = bartlettTest( x, y, z )\n\n > var arr = [ 2.9, 3.0, 2.5, 2.6, 3.2,\n ... 3.8, 2.7, 4.0, 2.4,\n ... 2.8, 3.4, 3.7, 2.2, 2.0\n ... ];\n > var groups = [\n ... 'a', 'a', 'a', 'a', 'a',\n ... 'b', 'b', 'b', 'b',\n ... 'c', 'c', 'c', 'c', 'c'\n ... ];\n > out = bartlettTest( arr, { 'groups': groups } )\n\n See Also\n --------\n vartest, leveneTest\n","base.abs":"\nbase.abs( x )\n Computes the absolute value of a double-precision floating-point number `x`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Absolute value.\n\n Examples\n --------\n > var y = base.abs( -1.0 )\n 1.0\n > y = base.abs( 2.0 )\n 2.0\n > y = base.abs( 0.0 )\n 0.0\n > y = base.abs( -0.0 )\n 0.0\n > y = base.abs( NaN )\n NaN\n\n See Also\n --------\n base.abs2, base.absf, base.labs\n","base.abs2":"\nbase.abs2( x )\n Computes the squared absolute value of a double-precision floating-point\n `x`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Squared absolute value.\n\n Examples\n --------\n > var y = base.abs2( -1.0 )\n 1.0\n > y = base.abs2( 2.0 )\n 4.0\n > y = base.abs2( 0.0 )\n 0.0\n > y = base.abs2( -0.0 )\n 0.0\n > y = base.abs2( NaN )\n NaN\n\n See Also\n --------\n base.abs, base.abs2f\n","base.abs2f":"\nbase.abs2f( x )\n Computes the squared absolute value of a single-precision floating-point\n `x`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Squared absolute value.\n\n Examples\n --------\n > var y = base.abs2f( -1.0 )\n 1.0\n > y = base.abs2f( 2.0 )\n 4.0\n > y = base.abs2f( 0.0 )\n 0.0\n > y = base.abs2f( -0.0 )\n 0.0\n > y = base.abs2f( NaN )\n NaN\n\n See Also\n --------\n base.abs2, base.absf\n","base.absdiff":"\nbase.absdiff( x, y )\n Computes the absolute difference.\n\n Parameters\n ----------\n x: number\n First number.\n\n y: number\n Second number.\n\n Returns\n -------\n out: number\n Absolute difference.\n\n Examples\n --------\n > var d = base.absdiff( 2.0, 5.0 )\n 3.0\n > d = base.absdiff( -1.0, 3.14 )\n ~4.14\n > d = base.absdiff( 10.1, -2.05 )\n ~12.15\n > d = base.absdiff( -0.0, 0.0 )\n +0.0\n > d = base.absdiff( NaN, 5.0 )\n NaN\n > d = base.absdiff( PINF, NINF )\n Infinity\n > d = base.absdiff( PINF, PINF )\n NaN\n\n See Also\n --------\n base.reldiff, base.epsdiff\n","base.absf":"\nbase.absf( x )\n Computes the absolute value of a single-precision floating-point number `x`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Absolute value.\n\n Examples\n --------\n > var y = base.absf( -1.0 )\n 1.0\n > y = base.absf( 2.0 )\n 2.0\n > y = base.absf( 0.0 )\n 0.0\n > y = base.absf( -0.0 )\n 0.0\n > y = base.absf( NaN )\n NaN\n\n See Also\n --------\n base.abs, base.abs2f, base.labs\n","base.acartesianPower":"\nbase.acartesianPower( x, n )\n Returns the Cartesian power.\n\n If provided an empty array, the function returns an empty array.\n\n If `n` is less than or equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n n: integer\n Power.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var x = [ 1, 2 ];\n > var out = base.acartesianPower( x, 2 )\n [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ]\n\n See Also\n --------\n acartesianPower, base.acartesianProduct, base.acartesianSquare\n","base.acartesianProduct":"\nbase.acartesianProduct( x1, x2 )\n Returns the Cartesian product.\n\n If provided one or more empty arrays, the function returns an empty array.\n\n Parameters\n ----------\n x1: ArrayLikeObject\n First input array.\n\n x2: ArrayLikeObject\n Second input array.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var x1 = [ 1, 2 ];\n > var x2 = [ 3, 4 ];\n > var out = base.acartesianProduct( x1, x2 )\n [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ] ]\n\n See Also\n --------\n acartesianProduct, base.acartesianPower, base.acartesianSquare\n","base.acartesianSquare":"\nbase.acartesianSquare( x )\n Returns the Cartesian square.\n\n If provided an empty array, the function returns an empty array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n Returns\n -------\n out: Array\n Cartesian product.\n\n Examples\n --------\n > var x = [ 1, 2 ];\n > var out = base.acartesianSquare( x )\n [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ]\n\n See Also\n --------\n acartesianSquare, base.acartesianPower, base.acartesianProduct\n","base.acos":"\nbase.acos( x )\n Compute the arccosine of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosine (in radians).\n\n Examples\n --------\n > var y = base.acos( 1.0 )\n 0.0\n > y = base.acos( 0.707 )\n ~0.7855\n > y = base.acos( NaN )\n NaN\n\n See Also\n --------\n base.acosh, base.asin, base.atan\n","base.acosd":"\nbase.acosd( x )\n Computes the arccosine (in degrees) of a double-precision floating-point \n number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosine (in degrees).\n\n Examples\n --------\n > var y = base.acosd( 0.0 )\n 90.0\n > y = base.acosd( PI/6.0 )\n ~58.43\n > y = base.acosd( NaN )\n NaN\n\n See Also\n --------\n base.acos, base.acosdf, base.acosh, base.asind, base.atand\n","base.acosdf":"\nbase.acosdf( x )\n Computes the arccosine (in degrees) of a single-precision floating-point\n number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosine (in degrees).\n\n Examples\n --------\n > var y = base.acosdf( 0.0 )\n 90.0\n > y = base.acosdf( FLOAT32_PI / 6.0 )\n ~58.43\n > y = base.acosdf( NaN )\n NaN\n\n See Also\n --------\n base.acosd, base.acosf, base.asindf\n","base.acosf":"\nbase.acosf( x )\n Computes the arccosine of a single-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosine (in radians).\n\n Examples\n --------\n > var y = base.acosf( 1.0 )\n 0.0\n > y = base.acosf( 0.707 )\n ~0.7855\n > y = base.acosf( NaN )\n NaN\n\n See Also\n --------\n base.acos, base.acosh, base.asinf, base.atanf\n","base.acosh":"\nbase.acosh( x )\n Computes the hyperbolic arccosine of a double-precision floating-point\n number.\n\n If `x < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arccosine.\n\n Examples\n --------\n > var y = base.acosh( 1.0 )\n 0.0\n > y = base.acosh( 2.0 )\n ~1.317\n > y = base.acosh( NaN )\n NaN\n\n See Also\n --------\n base.acos, base.asinh, base.atanh\n","base.acot":"\nbase.acot( x )\n Computes the inverse cotangent of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse cotangent (in radians).\n\n Examples\n --------\n > var y = base.acot( 2.0 )\n ~0.4636\n > y = base.acot( 0.0 )\n ~1.5708\n > y = base.acot( 0.5 )\n ~1.1071\n > y = base.acot( 1.0 )\n ~0.7854\n > y = base.acot( NaN )\n NaN\n\n See Also\n --------\n base.acoth, base.atan, base.cot\n","base.acotd":"\nbase.acotd( x )\n Computes the arccotangent (in degrees) of a double-precision floating-point\n number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccotangent (in degrees).\n\n Examples\n --------\n > var y = base.acotd( 0.0 )\n 90.0\n > y = base.acotd( PI/6.0 )\n ~62.36\n > y = base.acotd( NaN )\n NaN\n\n See Also\n --------\n base.acot, base.acotdf, base.acoth, base.atand, base.cotd\n","base.acotdf":"\nbase.acotdf( x )\n Computes the arccotangent (in degrees) of a single-precision floating-point\n number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccotangent (in degrees).\n\n Examples\n --------\n > var y = base.acotdf( 0.0 )\n 90.0\n > y = base.acotdf( FLOAT32_PI/6.0 )\n ~62.36\n > y = base.acotdf( NaN )\n NaN\n\n See Also\n --------\n base.acotd, base.acotf\n","base.acotf":"\nbase.acotf( x )\n Computes the inverse cotangent of a single-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse cotangent (in radians).\n\n Examples\n --------\n > var y = base.acotf( 2.0 )\n ~0.4636\n > y = base.acotf( 0.0 )\n ~1.5708\n > y = base.acotf( 0.5 )\n ~1.1071\n > y = base.acotf( 1.0 )\n ~0.7854\n > y = base.acotf( NaN )\n NaN\n\n See Also\n --------\n base.acot, base.acoth, base.atanf\n","base.acoth":"\nbase.acoth( x )\n Computes the inverse hyperbolic cotangent of a double-precision floating-\n point number.\n\n The domain of the inverse hyperbolic cotangent is the union of the intervals\n (-inf,-1] and [1,inf).\n\n If provided a value on the open interval (-1,1), the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse hyperbolic cotangent.\n\n Examples\n --------\n > var y = base.acoth( 2.0 )\n ~0.5493\n > y = base.acoth( 0.0 )\n NaN\n > y = base.acoth( 0.5 )\n NaN\n > y = base.acoth( 1.0 )\n Infinity\n > y = base.acoth( NaN )\n NaN\n\n See Also\n --------\n base.acosh, base.acot, base.asinh, base.atanh\n","base.acovercos":"\nbase.acovercos( x )\n Computes the inverse coversed cosine.\n\n The inverse coversed cosine is defined as `asin(x-1)`.\n\n If `x < 0`, `x > 2`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse coversed cosine.\n\n Examples\n --------\n > var y = base.acovercos( 1.5 )\n ~0.5236\n > y = base.acovercos( -0.0 )\n ~-1.5708\n\n See Also\n --------\n base.acoversin, base.avercos, base.covercos, base.vercos\n","base.acoversin":"\nbase.acoversin( x )\n Computes the inverse coversed sine.\n\n The inverse coversed sine is defined as `asin(1-x)`.\n\n If `x < 0`, `x > 2`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse coversed sine.\n\n Examples\n --------\n > var y = base.acoversin( 1.5 )\n ~-0.5236\n > y = base.acoversin( 0.0 )\n ~1.5708\n\n See Also\n --------\n base.acovercos, base.aversin, base.coversin, base.versin\n","base.acsc":"\nbase.acsc( x )\n Computes the arccosecant of a number.\n\n If `|x| < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosecant (in radians).\n\n Examples\n --------\n > var y = base.acsc( 1.0 )\n ~1.57\n > y = base.acsc( PI )\n ~0.32\n > y = base.acsc( -PI )\n ~-0.32\n > y = base.acsc( NaN )\n NaN\n\n See Also\n --------\n base.acot, base.acsch, base.asec, base.asin, base.csc\n","base.acscd":"\nbase.acscd( x )\n Computes the arccosecant of (in degrees) a double-precision floating-point\n number.\n\n If `x` does not satisy `x >= 1` or `x <= -1`, the function returns NaN.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosecant (in degrees).\n\n Examples\n --------\n > var y = base.acscd( 0.0 )\n NaN\n > y = base.acscd( PI/6.0 )\n NaN\n > y = base.acscd( 1 )\n 90.0\n > y = base.acscd( NaN )\n NaN\n\n See Also\n --------\n base.acsc, base.acsch, base.asecd, base.asind, base.cscd\n","base.acscdf":"\nbase.acscdf( x )\n Computes the arccosecant (in degrees) of a single-precision floating-point\n number.\n\n If `x` does not satisy `x >= 1` or `x <= -1`, the function returns NaN.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosecant (in degrees).\n\n Examples\n --------\n > var y = base.acscdf( 0.0 )\n NaN\n > y = base.acscdf( 3.1415927410125732 / 6.0 )\n NaN\n > y = base.acscdf( 1.0 )\n 90.0\n > y = base.acscdf( NaN )\n NaN\n\n See Also\n --------\n base.acsc, base.acsch, base.asecdf, base.asindf\n","base.acscf":"\nbase.acscf( x )\n Computes the arccosecant of a single-precision floating-point number.\n\n If `|x| < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arccosecant (in radians).\n\n Examples\n --------\n > var y = base.acscf( 1.0 )\n ~1.57\n > y = base.acscf( 3.141592653589793 )\n ~0.32\n > y = base.acscf( -3.141592653589793 )\n ~-0.32\n > y = base.acscf( NaN )\n NaN\n\n See Also\n --------\n base.acsc, base.acsch, base.asecf, base.asinf\n","base.acsch":"\nbase.acsch( x )\n Computes the hyperbolic arccosecant of a number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arccosecant.\n\n Examples\n --------\n > var y = base.acsch( 0.0 )\n Infinity\n > y = base.acsch( -1.0 )\n ~-0.881\n > y = base.acsch( NaN )\n NaN\n\n See Also\n --------\n base.acoth, base.acsc, base.asech, base.asinh, base.csc, base.csch\n","base.add":"\nbase.add( x, y )\n Computes the sum of two double-precision floating-point numbers `x` and `y`.\n\n Parameters\n ----------\n x: number\n First input value.\n\n y: number\n Second input value.\n\n Returns\n -------\n z: number\n Sum.\n\n Examples\n --------\n > var v = base.add( -1.0, 5.0 )\n 4.0\n > v = base.add( 2.0, 5.0 )\n 7.0\n > v = base.add( 0.0, 5.0 )\n 5.0\n > v = base.add( -0.0, 0.0 )\n 0.0\n > v = base.add( NaN, NaN )\n NaN\n\n See Also\n --------\n base.div, base.mul, base.sub\n","base.add3":"\nbase.add3( x, y, z )\n Computes the sum of three double-precision floating-point numbers.\n\n Parameters\n ----------\n x: number\n First input value.\n\n y: number\n Second input value.\n\n z: number\n Third input value.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n > var v = base.add3( -1.0, 5.0, 2.0 )\n 6.0\n > v = base.add3( 2.0, 5.0, 2.0 )\n 9.0\n > v = base.add3( 0.0, 5.0, 2.0 )\n 7.0\n > v = base.add3( -0.0, 0.0, -0.0 )\n 0.0\n > v = base.add3( NaN, NaN, NaN )\n NaN\n\n See Also\n --------\n base.add\n","base.add4":"\nbase.add4( x, y, z, w )\n Computes the sum of four double-precision floating-point numbers.\n\n Parameters\n ----------\n x: number\n First input value.\n\n y: number\n Second input value.\n\n z: number\n Third input value.\n\n w: number\n Fourth input value.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n > var v = base.add4( -1.0, 5.0, 2.0, -3.0 )\n 3.0\n > v = base.add4( 2.0, 5.0, 2.0, -3.0 )\n 6.0\n > v = base.add4( 0.0, 5.0, 2.0, -3.0 )\n 4.0\n > v = base.add4( -0.0, 0.0, -0.0, -0.0 )\n 0.0\n > v = base.add4( NaN, NaN, NaN, NaN )\n NaN\n\n See Also\n --------\n base.add\n","base.add5":"\nbase.add5( x, y, z, w, u )\n Computes the sum of five double-precision floating-point numbers.\n\n Parameters\n ----------\n x: number\n First input value.\n\n y: number\n Second input value.\n\n z: number\n Third input value.\n\n w: number\n Fourth input value.\n\n u: number\n Fifth input value.\n\n Returns\n -------\n out: number\n Sum.\n\n Examples\n --------\n > var v = base.add5( -1.0, 5.0, 2.0, -3.0, 4.0 )\n 7.0\n > v = base.add5( 2.0, 5.0, 2.0, -3.0, 4.0 )\n 10.0\n > v = base.add5( 0.0, 5.0, 2.0, -3.0, 4.0 )\n 8.0\n > v = base.add5( -0.0, 0.0, -0.0, -0.0, -0.0 )\n 0.0\n > v = base.add5( NaN, NaN, NaN, NaN, NaN )\n NaN\n\n See Also\n --------\n base.add\n","base.addf":"\nbase.addf( x, y )\n Computes the sum of two single-precision floating-point numbers `x` and `y`.\n\n Parameters\n ----------\n x: number\n First input value.\n\n y: number\n Second input value.\n\n Returns\n -------\n z: number\n Sum.\n\n Examples\n --------\n > var v = base.addf( -1.0, 5.0 )\n 4.0\n > v = base.addf( 2.0, 5.0 )\n 7.0\n > v = base.addf( 0.0, 5.0 )\n 5.0\n > v = base.addf( -0.0, 0.0 )\n 0.0\n > v = base.addf( NaN, NaN )\n NaN\n\n See Also\n --------\n base.add, base.divf, base.mulf, base.subf\n","base.afilled":"\nbase.afilled( value, len )\n Returns a filled \"generic\" array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n len: integer\n Array length.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afilled( 0.0, 3 )\n [ 0.0, 0.0, 0.0 ]\n\n","base.afilled2d":"\nbase.afilled2d( value, shape )\n Returns a filled two-dimensional nested array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afilled2d( 0.0, [ 1, 3 ] )\n [ [ 0.0, 0.0, 0.0 ] ]\n\n","base.afilled2dBy":"\nbase.afilled2dBy( shape, clbk[, thisArg] )\n Returns a filled two-dimensional nested array according to a provided\n callback function.\n\n The callback function is provided one argument:\n\n - indices: current array element indices.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilled2dBy( [ 1, 3 ], clbk )\n [ [ 1.0, 1.0, 1.0 ] ]\n\n See Also\n --------\n base.afilled2d\n","base.afilled3d":"\nbase.afilled3d( value, shape )\n Returns a filled three-dimensional nested array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afilled3d( 0.0, [ 1, 1, 3 ] )\n [ [ [ 0.0, 0.0, 0.0 ] ] ]\n\n","base.afilled3dBy":"\nbase.afilled3dBy( shape, clbk[, thisArg] )\n Returns a filled three-dimensional nested array according to a provided\n callback function.\n\n The callback function is provided one argument:\n\n - indices: current array element indices.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilled3dBy( [ 1, 1, 3 ], clbk )\n [ [ [ 1.0, 1.0, 1.0 ] ] ]\n\n See Also\n --------\n base.afilled3d\n","base.afilled4d":"\nbase.afilled4d( value, shape )\n Returns a filled four-dimensional nested array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afilled4d( 0.0, [ 1, 1, 1, 3 ] )\n [ [ [ [ 0.0, 0.0, 0.0 ] ] ] ]\n\n","base.afilled4dBy":"\nbase.afilled4dBy( shape, clbk[, thisArg] )\n Returns a filled four-dimensional nested array according to a provided\n callback function.\n\n The callback function is provided one argument:\n\n - indices: current array element indices.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilled4dBy( [ 1, 1, 1, 3 ], clbk )\n [ [ [ [ 1.0, 1.0, 1.0 ] ] ] ]\n\n See Also\n --------\n base.afilled4d\n","base.afilled5d":"\nbase.afilled5d( value, shape )\n Returns a filled five-dimensional nested array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afilled5d( 0.0, [ 1, 1, 1, 1, 3 ] )\n [ [ [ [ [ 0.0, 0.0, 0.0 ] ] ] ] ]\n\n","base.afilled5dBy":"\nbase.afilled5dBy( shape, clbk[, thisArg] )\n Returns a filled five-dimensional nested array according to a provided\n callback function.\n\n The callback function is provided one argument:\n\n - indices: current array element indices.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilled5dBy( [ 1, 1, 1, 1, 3 ], clbk )\n [ [ [ [ [ 1.0, 1.0, 1.0 ] ] ] ] ]\n\n See Also\n --------\n base.afilled5d\n","base.afilledBy":"\nbase.afilledBy( len, clbk[, thisArg] )\n Returns a filled \"generic\" array according to a provided callback function.\n\n Parameters\n ----------\n len: integer\n Array length.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilledBy( 3, clbk )\n [ 1.0, 1.0, 1.0 ]\n\n See Also\n --------\n base.afilled\n","base.afillednd":"\nbase.afillednd( value, shape )\n Returns a filled n-dimensional nested array.\n\n Parameters\n ----------\n value: any\n Fill value.\n\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afillednd( 0.0, [ 1, 3 ] )\n [ [ 0.0, 0.0, 0.0 ] ]\n\n","base.afilledndBy":"\nbase.afilledndBy( shape, clbk[, thisArg] )\n Returns a filled n-dimensional nested array according to a callback\n function.\n\n The callback function is provided one argument:\n\n - indices: current array element indices.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function clbk() { return 1.0; };\n > var out = base.afilledndBy( [ 1, 3 ], clbk )\n [ [ 1.0, 1.0, 1.0 ] ]\n\n See Also\n --------\n base.afillednd\n","base.afilter":"\nbase.afilter( x, predicate[, thisArg] )\n Returns a shallow copy of an array containing only those elements which pass\n a test implemented by a predicate function.\n\n The predicate function is provided three arguments:\n\n - value: current array element.\n - index: current array element index.\n - arr: the input array.\n\n If provided an array-like object having a `filter` method , the function\n defers execution to that method and assumes that the method has the\n following signature:\n\n x.filter( predicate, thisArg )\n\n If provided an array-like object without a `filter` method, the function\n performs a linear scan and always returns a generic array.\n\n Parameters\n ----------\n x: Array|TypedArray|Object\n Input array.\n\n predicate: Function\n Predicate function.\n\n thisArg: any (optional)\n Execution context.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Output array.\n\n Examples\n --------\n > function f( v ) { return ( v > 0 ); };\n > var x = [ 1, -2, -3, 4 ];\n > var out = base.afilter( x, f )\n [ 1, 4 ]\n\n","base.afirst":"\nbase.afirst( arr )\n Returns the first element of an array-like object.\n\n Parameters\n ----------\n arr: ArrayLikeObject\n Input array.\n\n Returns\n -------\n out: any\n First element.\n\n Examples\n --------\n > var out = base.afirst( [ 1, 2, 3 ] )\n 1\n\n","base.aflatten":"\nbase.aflatten( x, shape, colexicographic )\n Flattens an n-dimensional nested array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = base.aflatten( x, [ 2, 2 ], false )\n [ 1, 2, 3, 4 ]\n > out = base.aflatten( x, [ 2, 2 ], true )\n [ 1, 3, 2, 4 ]\n\n\nbase.aflatten.assign( x, shape, colexicographic, out, stride, offset )\n Flattens an n-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten.assign( x, [ 2, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten.assign( x, [ 2, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflattenBy\n","base.aflatten.assign":"\nbase.aflatten.assign( x, shape, colexicographic, out, stride, offset )\n Flattens an n-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten.assign( x, [ 2, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten.assign( x, [ 2, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflattenBy","base.aflatten2d":"\nbase.aflatten2d( x, shape, colexicographic )\n Flattens a two-dimensional nested array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = base.aflatten2d( x, [ 2, 2 ], false )\n [ 1, 2, 3, 4 ]\n > out = base.aflatten2d( x, [ 2, 2 ], true )\n [ 1, 3, 2, 4 ]\n\n\nbase.aflatten2d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a two-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten2d.assign( x, [ 2, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten2d.assign( x, [ 2, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten2dBy\n","base.aflatten2d.assign":"\nbase.aflatten2d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a two-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten2d.assign( x, [ 2, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten2d.assign( x, [ 2, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten2dBy","base.aflatten2dBy":"\nbase.aflatten2dBy( x, shape, colex, clbk[, thisArg] )\n Flattens a two-dimensional nested array according to a callback function.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = base.aflatten2dBy( x, [ 2, 2 ], false, fcn )\n [ 2, 4, 6, 8 ]\n > out = base.aflatten2dBy( x, [ 2, 2 ], true, fcn )\n [ 2, 6, 4, 8 ]\n\n\nbase.aflatten2dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a two-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten2dBy.assign( x, [ 2, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten2dBy.assign( x, [ 2, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten2d\n","base.aflatten2dBy.assign":"\nbase.aflatten2dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a two-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten2dBy.assign( x, [ 2, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten2dBy.assign( x, [ 2, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten2d","base.aflatten3d":"\nbase.aflatten3d( x, shape, colexicographic )\n Flattens a three-dimensional nested array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = base.aflatten3d( x, [ 2, 1, 2 ], false )\n [ 1, 2, 3, 4 ]\n > out = base.aflatten3d( x, [ 2, 1, 2 ], true )\n [ 1, 3, 2, 4 ]\n\n\nbase.aflatten3d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a three-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten3d.assign( x, [ 2, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten3d.assign( x, [ 2, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten3dBy\n","base.aflatten3d.assign":"\nbase.aflatten3d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a three-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten3d.assign( x, [ 2, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten3d.assign( x, [ 2, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten3dBy","base.aflatten3dBy":"\nbase.aflatten3dBy( x, shape, colex, clbk[, thisArg] )\n Flattens a three-dimensional nested array according to a callback function.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = base.aflatten3dBy( x, [ 2, 1, 2 ], false, fcn )\n [ 2, 4, 6, 8 ]\n > out = base.aflatten3dBy( x, [ 2, 1, 2 ], true, fcn )\n [ 2, 6, 4, 8 ]\n\n\nbase.aflatten3dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a three-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten3dBy.assign( x, [ 2, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten3dBy.assign( x, [ 2, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten3d\n","base.aflatten3dBy.assign":"\nbase.aflatten3dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a three-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten3dBy.assign( x, [ 2, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten3dBy.assign( x, [ 2, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten3d","base.aflatten4d":"\nbase.aflatten4d( x, shape, colexicographic )\n Flattens a four-dimensional nested array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = base.aflatten4d( x, [ 2, 1, 1, 2 ], false )\n [ 1, 2, 3, 4 ]\n > out = base.aflatten4d( x, [ 2, 1, 1, 2 ], true )\n [ 1, 3, 2, 4 ]\n\n\nbase.aflatten4d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a four-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten4d.assign( x, [ 2, 1, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten4d.assign( x, [ 2, 1, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten4dBy\n","base.aflatten4d.assign":"\nbase.aflatten4d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a four-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten4d.assign( x, [ 2, 1, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten4d.assign( x, [ 2, 1, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten4dBy","base.aflatten4dBy":"\nbase.aflatten4dBy( x, shape, colex, clbk[, thisArg] )\n Flattens a four-dimensional nested array according to a callback function.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = base.aflatten4dBy( x, [ 2, 1, 1, 2 ], false, fcn )\n [ 2, 4, 6, 8 ]\n > out = base.aflatten4dBy( x, [ 2, 1, 1, 2 ], true, fcn )\n [ 2, 6, 4, 8 ]\n\n\nbase.aflatten4dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a four-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten4dBy.assign( x, [ 2, 1, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten4dBy.assign( x, [ 2, 1, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten4d\n","base.aflatten4dBy.assign":"\nbase.aflatten4dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a four-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ 1, 2 ] ] ], [ [ [ 3, 4 ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten4dBy.assign( x, [ 2, 1, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten4dBy.assign( x, [ 2, 1, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten4d","base.aflatten5d":"\nbase.aflatten5d( x, shape, colexicographic )\n Flattens a five-dimensional nested array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = base.aflatten5d( x, [ 2, 1, 1, 1, 2 ], false )\n [ 1, 2, 3, 4 ]\n > out = base.aflatten5d( x, [ 2, 1, 1, 1, 2 ], true )\n [ 1, 3, 2, 4 ]\n\n\nbase.aflatten5d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a five-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten5d.assign( x, [ 2, 1, 1, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten5d.assign( x, [ 2, 1, 1, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten5dBy\n","base.aflatten5d.assign":"\nbase.aflatten5d.assign( x, shape, colexicographic, out, stride, offset )\n Flattens a five-dimensional nested array and assigns elements to a provided\n output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colexicographic: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten5d.assign( x, [ 2, 1, 1, 1, 2 ], false, out, 1, 0 )\n [ 1, 2, 3, 4 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten5d.assign( x, [ 2, 1, 1, 1, 2 ], true, out, 1, 0 );\n > out\n [ 1, 3, 2, 4 ]\n\n See Also\n --------\n base.aflatten5dBy","base.aflatten5dBy":"\nbase.aflatten5dBy( x, shape, colex, clbk[, thisArg] )\n Flattens a five-dimensional nested array according to a callback function.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = base.aflatten5dBy( x, [ 2, 1, 1, 1, 2 ], false, fcn )\n [ 2, 4, 6, 8 ]\n > out = base.aflatten5dBy( x, [ 2, 1, 1, 1, 2 ], true, fcn )\n [ 2, 6, 4, 8 ]\n\n\nbase.aflatten5dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a five-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten5dBy.assign( x, [ 2, 1, 1, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten5dBy.assign( x, [ 2, 1, 1, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten5d\n","base.aflatten5dBy.assign":"\nbase.aflatten5dBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens a five-dimensional nested array according to a callback function\n and assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ [ [ [ 1, 2 ] ] ] ], [ [ [ [ 3, 4 ] ] ] ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflatten5dBy.assign( x, [ 2, 1, 1, 1, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflatten5dBy.assign( x, [ 2, 1, 1, 1, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten5d","base.aflattenBy":"\nbase.aflattenBy( x, shape, colex, clbk[, thisArg] )\n Flattens an n-dimensional nested array according to a callback function.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Flattened array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = base.aflattenBy( x, [ 2, 2 ], false, fcn )\n [ 2, 4, 6, 8 ]\n > out = base.aflattenBy( x, [ 2, 2 ], true, fcn )\n [ 2, 6, 4, 8 ]\n\n\nbase.aflattenBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens an n-dimensional nested array according to a callback function and\n assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflattenBy.assign( x, [ 2, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflattenBy.assign( x, [ 2, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten\n","base.aflattenBy.assign":"\nbase.aflattenBy.assign( x, shape, colex, out, stride, offset, clbk[, thisArg] )\n Flattens an n-dimensional nested array according to a callback function and\n assigns elements to a provided output array.\n\n The function assumes that all nested arrays have the same length (i.e., the\n input array is *not* a ragged array).\n\n The callback function is provided the following arguments:\n\n - value: nested array element.\n - indices: element indices (in lexicographic order).\n - arr: the input array.\n\n Parameters\n ----------\n x: Array\n Input array.\n\n shape: Array\n Array shape.\n\n colex: boolean\n Specifies whether to flatten array values in colexicographic order.\n\n out: Collection\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n clbk: Function\n Callback function.\n\n thisArg: any (optional)\n Callback execution context.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > function fcn( v ) { return v * 2; };\n > var x = [ [ 1, 2 ], [ 3, 4 ] ];\n > var out = [ 0, 0, 0, 0 ];\n > var v = base.aflattenBy.assign( x, [ 2, 2 ], false, out, 1, 0, fcn )\n [ 2, 4, 6, 8 ]\n > var bool = ( v === out )\n true\n > out = [ 0, 0, 0, 0 ];\n > base.aflattenBy.assign( x, [ 2, 2 ], true, out, 1, 0, fcn );\n > out\n [ 2, 6, 4, 8 ]\n\n See Also\n --------\n base.aflatten","base.afliplr2d":"\nbase.afliplr2d( x )\n Reverses the order of elements along the last dimension of a two-dimensional\n nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afliplr2d( [ [ 1, 2 ], [ 3, 4 ] ] )\n [ [ 2, 1 ], [ 4, 3 ] ]\n\n See Also\n --------\n base.afliplr3d, base.afliplr4d, base.afliplr5d\n","base.afliplr3d":"\nbase.afliplr3d( x )\n Reverses the order of elements along the last dimension of a three-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afliplr3d( [ [ [ 1, 2 ], [ 3, 4 ] ] ] )\n [ [ [ 2, 1 ], [ 4, 3 ] ] ]\n\n See Also\n --------\n base.afliplr2d, base.afliplr4d, base.afliplr5d\n","base.afliplr4d":"\nbase.afliplr4d( x )\n Reverses the order of elements along the last dimension of a four-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afliplr4d( [ [ [ [ 1, 2 ], [ 3, 4 ] ] ] ] )\n [ [ [ [ 2, 1 ], [ 4, 3 ] ] ] ]\n\n See Also\n --------\n base.afliplr2d, base.afliplr3d, base.afliplr5d\n","base.afliplr5d":"\nbase.afliplr5d( x )\n Reverses the order of elements along the last dimension of a five-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.afliplr5d( [ [ [ [ [ 1, 2 ], [ 3, 4 ] ] ] ] ] )\n [ [ [ [ [ 2, 1 ], [ 4, 3 ] ] ] ] ]\n\n See Also\n --------\n base.afliplr2d, base.afliplr3d, base.afliplr4d\n","base.aflipud2d":"\nbase.aflipud2d( x )\n Reverses the order of elements along the first dimension of a two-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aflipud2d( [ [ 1, 2 ], [ 3, 4 ] ] )\n [ [ 3, 4 ], [ 1, 2 ] ]\n\n See Also\n --------\n base.aflipud3d, base.aflipud4d, base.aflipud5d\n","base.aflipud3d":"\nbase.aflipud3d( x )\n Reverses the order of elements along the second-to-last dimension of a\n three-dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aflipud3d( [ [ [ 1, 2 ], [ 3, 4 ] ] ] )\n [ [ [ 3, 4 ], [ 1, 2 ] ] ]\n\n See Also\n --------\n base.aflipud2d, base.aflipud4d, base.aflipud5d\n","base.aflipud4d":"\nbase.aflipud4d( x )\n Reverses the order of elements along the second-to-last dimension of a four-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aflipud4d( [ [ [ [ 1, 2 ], [ 3, 4 ] ] ] ] )\n [ [ [ [ 3, 4 ], [ 1, 2 ] ] ] ]\n\n See Also\n --------\n base.aflipud2d, base.aflipud3d, base.aflipud5d\n","base.aflipud5d":"\nbase.aflipud5d( x )\n Reverses the order of elements along the second-to-last dimension of a five-\n dimensional nested input array.\n\n The function does *not* perform a deep copy of nested array elements.\n\n Parameters\n ----------\n x: ArrayLikeObject\n Input nested array.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aflipud5d( [ [ [ [ [ 1, 2 ], [ 3, 4 ] ] ] ] ] )\n [ [ [ [ [ 3, 4 ], [ 1, 2 ] ] ] ] ]\n\n See Also\n --------\n base.aflipud2d, base.aflipud3d, base.aflipud4d\n","base.ahavercos":"\nbase.ahavercos( x )\n Computes the inverse half-value versed cosine.\n\n The inverse half-value versed cosine is defined as `2*acos(sqrt(x))`.\n\n If `x < 0`, `x > 1`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse half-value versed cosine.\n\n Examples\n --------\n > var y = base.ahavercos( 0.5 )\n ~1.5708\n > y = base.ahavercos( 0.0 )\n ~3.1416\n\n See Also\n --------\n base.ahaversin, base.havercos, base.vercos\n","base.ahaversin":"\nbase.ahaversin( x )\n Computes the inverse half-value versed sine.\n\n The inverse half-value versed sine is defined as `2*asin(sqrt(x))`.\n\n If `x < 0`, `x > 1`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse half-value versed sine.\n\n Examples\n --------\n > var y = base.ahaversin( 0.5 )\n ~1.5708\n > y = base.ahaversin( 0.0 )\n 0.0\n\n See Also\n --------\n base.ahavercos, base.haversin, base.versin\n","base.altcase":"\nbase.altcase( str )\n Converts a string to alternate case.\n\n Parameters\n ----------\n str: string\n Input string.\n\n Returns\n -------\n out: string\n Alternate-cased string.\n\n Examples\n --------\n > var out = base.altcase( 'Hello World!' )\n 'hElLo wOrLd!'\n > out = base.altcase( 'I am a tiny little teapot' )\n 'i aM A TiNy lItTlE TeApOt'\n\n See Also\n --------\n base.lowercase, base.uppercase","base.aones":"\nbase.aones( len )\n Returns a \"generic\" array filled with ones.\n\n Parameters\n ----------\n len: integer\n Array length.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aones( 3 )\n [ 1.0, 1.0, 1.0 ]\n\n See Also\n --------\n base.azeros, base.aones2d, base.aones3d, base.aones4d, base.aones5d, base.aonesnd\n","base.aones2d":"\nbase.aones2d( shape )\n Returns a two-dimensional nested array filled with ones.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aones2d( [ 1, 3 ] )\n [ [ 1.0, 1.0, 1.0 ] ]\n\n See Also\n --------\n base.azeros2d, base.aones, base.aones3d, base.aones4d, base.aones5d, base.aonesnd\n","base.aones3d":"\nbase.aones3d( shape )\n Returns a three-dimensional nested array filled with ones.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aones3d( [ 1, 1, 3 ] )\n [ [ [ 1.0, 1.0, 1.0 ] ] ]\n\n See Also\n --------\n base.azeros3d, base.aones, base.aones2d, base.aones4d, base.aones5d, base.aonesnd\n","base.aones4d":"\nbase.aones4d( shape )\n Returns a four-dimensional nested array filled with ones.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aones4d( [ 1, 1, 1, 3 ] )\n [ [ [ [ 1.0, 1.0, 1.0 ] ] ] ]\n\n See Also\n --------\n base.azeros4d, base.aones, base.aones2d, base.aones3d, base.aones5d, base.aonesnd\n","base.aones5d":"\nbase.aones5d( shape )\n Returns a five-dimensional nested array filled with ones.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aones5d( [ 1, 1, 1, 1, 3 ] )\n [ [ [ [ [ 1.0, 1.0, 1.0 ] ] ] ] ]\n\n See Also\n --------\n base.azeros5d, base.aones, base.aones2d, base.aones3d, base.aones4d, base.aonesnd\n","base.aonesnd":"\nbase.aonesnd( shape )\n Returns an n-dimensional nested array filled with ones.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.aonesnd( [ 1, 3 ] )\n [ [ 1.0, 1.0, 1.0 ] ]\n\n See Also\n --------\n base.azerosnd, base.aones, base.aones2d, base.aones3d, base.aones4d, base.aones5d\n","base.aoneTo":"\nbase.aoneTo( n )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from one.\n\n If `n` is a non-integer value greater than zero, the function returns an\n array having `ceil(n)` elements.\n\n If `n` is less than or equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n n: number\n Number of elements.\n\n Returns\n -------\n out: Array\n Linearly spaced numeric array.\n\n Examples\n --------\n > var arr = base.aoneTo( 6 )\n [ 1, 2, 3, 4, 5, 6 ]\n\n\nbase.aoneTo.assign( out, stride, offset )\n Fills an array with linearly spaced numeric elements which increment by 1\n starting from one.\n\n Parameters\n ----------\n out: ArrayLikeObject\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = [ 0, 0, 0, 0, 0, 0 ];\n > base.aoneTo.assign( out, -1, out.length-1 );\n > out\n [ 6, 5, 4, 3, 2, 1 ]\n\n See Also\n --------\n base.azeroTo, base.aones\n","base.aoneTo.assign":"\nbase.aoneTo.assign( out, stride, offset )\n Fills an array with linearly spaced numeric elements which increment by 1\n starting from one.\n\n Parameters\n ----------\n out: ArrayLikeObject\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = [ 0, 0, 0, 0, 0, 0 ];\n > base.aoneTo.assign( out, -1, out.length-1 );\n > out\n [ 6, 5, 4, 3, 2, 1 ]\n\n See Also\n --------\n base.azeroTo, base.aones","base.args2multislice":"\nbase.args2multislice( args )\n Creates a MultiSlice object from a list of MultiSlice constructor arguments.\n\n Parameters\n ----------\n args: Array\n Constructor arguments.\n\n Returns\n -------\n s: MultiSlice\n MultiSlice instance.\n\n Examples\n --------\n > var args = [ null, null, null ];\n > var s = new base.args2multislice( args );\n > s.data\n [ null, null, null ]\n > args = [ 10, new Slice( 0, 10, 1 ), null ];\n > s = new base.args2multislice( args );\n > s.data\n [ 10, , null ]\n\n","base.asec":"\nbase.asec( x )\n Computes the inverse (arc) secant of a number.\n\n If `x > -1` and `x < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse (arc) secant.\n\n Examples\n --------\n > var y = base.asec( 1.0 )\n 0.0\n > y = base.asec( 2.0 )\n ~1.0472\n > y = base.asec( NaN )\n NaN\n\n See Also\n --------\n base.acot, base.acsc, base.asech, base.acos\n","base.asecd":"\nbase.asecd( x )\n Computes the arcsecant (in degrees) of a double-precision floating-point\n number.\n\n If `x` does not satisy `x >= 1` or `x <= -1`, the function returns NaN.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsecant (in degrees).\n\n Examples\n --------\n > var y = base.asecd( 0.0 )\n NaN\n > y = base.asecd( 2 )\n ~60.0\n > y = base.asecd( NaN )\n NaN\n\n See Also\n --------\n base.asec, base.asech, base.acosd, base.secd\n","base.asecdf":"\nbase.asecdf( x )\n Computes the arcsecant (in degrees) of a single-precision floating-point\n number.\n\n If `x` does not satisy `x >= 1` or `x <= -1`, the function returns NaN.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsecant (in degrees).\n\n Examples\n --------\n > var y = base.asecdf( 2.0 )\n ~60.0\n > y = base.asecdf( 0.0 )\n NaN\n > y = base.asecdf( NaN )\n NaN\n\n See Also\n --------\n base.asec, base.asech, base.acosdf\n","base.asecf":"\nbase.asecf( x )\n Computes the inverse (arc) secant of a single-precision\n floating-point number.\n\n If `x > -1` and `x < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse (arc) secant.\n\n Examples\n --------\n > var y = base.asecf( 1.0 )\n 0.0\n > y = base.asecf( 2.0 )\n ~1.0472\n > y = base.asecf( NaN )\n NaN\n\n See Also\n --------\n base.asec, base.asech, base.acosf\n","base.asech":"\nbase.asech( x )\n Computes the hyperbolic arcsecant of a number.\n\n If `x < 0` or `x > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arcsecant.\n\n Examples\n --------\n > var y = base.asech( 1.0 )\n 0.0\n > y = base.asech( 0.5 )\n ~1.317\n > y = base.asech( NaN )\n NaN\n\n See Also\n --------\n base.acosh, base.asec, base.asech, base.acoth\n","base.asin":"\nbase.asin( x )\n Computes the arcsine of a double-precision floating-point number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsine (in radians).\n\n Examples\n --------\n > var y = base.asin( 0.0 )\n 0.0\n > y = base.asin( -PI/6.0 )\n ~-0.551\n > y = base.asin( NaN )\n NaN\n\n See Also\n --------\n base.acos, base.asinh, base.atan\n","base.asind":"\nbase.asind( x )\n Computes the arcsine (in degrees) of a double-precision floating-point\n number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsine (in degrees).\n\n Examples\n --------\n > var y = base.asind( 0.0 )\n 0.0\n > y = base.asind( PI / 6.0 )\n ~31.57\n > y = base.asind( NaN )\n NaN\n\n See Also\n --------\n base.asin, base.asinh, base.atand\n","base.asindf":"\nbase.asindf( x )\n Computes the arcsine (in degrees) of a single-precision floating-point\n number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsine (in degrees).\n\n Examples\n --------\n > var y = base.asindf( 0.0 )\n 0.0\n > y = base.asindf( 3.1415927410125732 / 6.0 )\n ~31.57\n > y = base.asindf( NaN )\n NaN\n\n See Also\n --------\n base.asinf, base.asind\n","base.asinf":"\nbase.asinf( x )\n Computes the arcsine of a single-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arcsine (in radians).\n\n Examples\n --------\n > var y = base.asinf( 0.0 )\n 0.0\n > y = base.asinf( -3.14/6.0 )\n ~-0.551\n > y = base.asinf( NaN )\n NaN\n\n See Also\n --------\n base.asin, base.asindf\n","base.asinh":"\nbase.asinh( x )\n Computes the hyperbolic arcsine of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arcsine.\n\n Examples\n --------\n > var y = base.asinh( 0.0 )\n 0.0\n > y = base.asinh( 2.0 )\n ~1.444\n > y = base.asinh( -2.0 )\n ~-1.444\n > y = base.asinh( NaN )\n NaN\n > y = base.asinh( NINF )\n -Infinity\n > y = base.asinh( PINF )\n Infinity\n\n See Also\n --------\n base.acosh, base.asin, base.atanh\n","base.atan":"\nbase.atan( x )\n Computes the arctangent of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arctangent (in radians).\n\n Examples\n --------\n > var y = base.atan( 0.0 )\n ~0.0\n > y = base.atan( -PI/2.0 )\n ~-1.004\n > y = base.atan( PI/2.0 )\n ~1.004\n > y = base.atan( NaN )\n NaN\n\n See Also\n --------\n base.acos, base.asin, base.atanh\n","base.atan2":"\nbase.atan2( y, x )\n Computes the angle in the plane (in radians) between the positive x-axis and\n the ray from (0,0) to the point (x,y).\n\n Parameters\n ----------\n y: number\n Coordinate along y-axis.\n\n x: number\n Coordinate along x-axis.\n\n Returns\n -------\n out: number\n Angle (in radians).\n\n Examples\n --------\n > var v = base.atan2( 2.0, 2.0 )\n ~0.785\n > v = base.atan2( 6.0, 2.0 )\n ~1.249\n > v = base.atan2( -1.0, -1.0 )\n ~-2.356\n > v = base.atan2( 3.0, 0.0 )\n ~1.571\n > v = base.atan2( -2.0, 0.0 )\n ~-1.571\n > v = base.atan2( 0.0, 0.0 )\n 0.0\n > v = base.atan2( 3.0, NaN )\n NaN\n > v = base.atan2( NaN, 2.0 )\n NaN\n\n See Also\n --------\n base.atan\n","base.atand":"\nbase.atand( x )\n Computes the arctangent (in degrees) of a double-precision floating-point\n number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arctangent (in degrees).\n\n Examples\n --------\n > var y = base.atand( 0.0 )\n 0.0\n > y = base.atand( PI/6.0 )\n ~27.64\n > y = base.atand( NaN )\n NaN\n\n See Also\n --------\n base.atan, base.atanh, base.acosd\n","base.atanf":"\nbase.atanf( x )\n Computes the arctangent of a single-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Arctangent (in radians).\n\n Examples\n --------\n > var y = base.atanf( 0.0 )\n 0.0\n > y = base.atanf( -3.14/4.0 )\n ~-0.666\n > y = base.atanf( 3.14/4.0 )\n ~0.666\n > y = base.atanf( NaN )\n NaN\n\n See Also\n --------\n base.atan, base.atanh, base.acosf\n","base.atanh":"\nbase.atanh( x )\n Computes the hyperbolic arctangent of a double-precision floating-point\n number.\n\n If `|x| > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arctangent.\n\n Examples\n --------\n > var y = base.atanh( 0.0 )\n 0.0\n > y = base.atanh( 0.9 )\n ~1.472\n > y = base.atanh( 1.0 )\n Infinity\n > y = base.atanh( -1.0 )\n -Infinity\n > y = base.atanh( NaN )\n NaN\n\n See Also\n --------\n base.acosh, base.asinh, base.atan\n","base.avercos":"\nbase.avercos( x )\n Computes the inverse versed cosine.\n\n The inverse versed cosine is defined as `acos(1+x)`.\n\n If `x < -2`, `x > 0`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse versed cosine.\n\n Examples\n --------\n > var y = base.avercos( -1.5 )\n ~2.0944\n > y = base.avercos( -0.0 )\n 0.0\n\n See Also\n --------\n base.aversin, base.versin\n","base.aversin":"\nbase.aversin( x )\n Computes the inverse versed sine.\n\n The inverse versed sine is defined as `acos(1-x)`.\n\n If `x < 0`, `x > 2`, or `x` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Inverse versed sine.\n\n Examples\n --------\n > var y = base.aversin( 1.5 )\n ~2.0944\n > y = base.aversin( 0.0 )\n 0.0\n\n See Also\n --------\n base.avercos, base.vercos\n","base.azeros":"\nbase.azeros( len )\n Returns a zero-filled \"generic\" array.\n\n Parameters\n ----------\n len: integer\n Array length.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azeros( 3 )\n [ 0.0, 0.0, 0.0 ]\n\n See Also\n --------\n base.aones, base.azeros2d, base.azeros3d, base.azeros4d, base.azeros5d, base.azerosnd\n","base.azeros2d":"\nbase.azeros2d( shape )\n Returns a zero-filled two-dimensional nested array.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azeros2d( [ 1, 3 ] )\n [ [ 0.0, 0.0, 0.0 ] ]\n\n See Also\n --------\n base.azeros, base.aones2d, base.azeros3d, base.azeros4d, base.azeros5d, base.azerosnd\n","base.azeros3d":"\nbase.azeros3d( shape )\n Returns a zero-filled three-dimensional nested array.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azeros3d( [ 1, 1, 3 ] )\n [ [ [ 0.0, 0.0, 0.0 ] ] ]\n\n See Also\n --------\n base.azeros, base.aones3d, base.azeros2d, base.azeros4d, base.azeros5d, base.azerosnd\n","base.azeros4d":"\nbase.azeros4d( shape )\n Returns a zero-filled four-dimensional nested array.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azeros4d( [ 1, 1, 1, 3 ] )\n [ [ [ [ 0.0, 0.0, 0.0 ] ] ] ]\n\n See Also\n --------\n base.azeros, base.aones4d, base.azeros2d, base.azeros3d, base.azeros5d, base.azerosnd\n","base.azeros5d":"\nbase.azeros5d( shape )\n Returns a zero-filled five-dimensional nested array.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azeros5d( [ 1, 1, 1, 1, 3 ] )\n [ [ [ [ [ 0.0, 0.0, 0.0 ] ] ] ] ]\n\n See Also\n --------\n base.azeros, base.aones5d, base.azeros2d, base.azeros3d, base.azeros4d, base.azerosnd\n","base.azerosnd":"\nbase.azerosnd( shape )\n Returns a zero-filled n-dimensional nested array.\n\n Parameters\n ----------\n shape: Array\n Array shape.\n\n Returns\n -------\n out: Array\n Output array.\n\n Examples\n --------\n > var out = base.azerosnd( [ 1, 3 ] )\n [ [ 0.0, 0.0, 0.0 ] ]\n\n See Also\n --------\n base.azeros, base.aonesnd, base.azeros2d, base.azeros3d, base.azeros4d, base.azeros5d\n","base.azeroTo":"\nbase.azeroTo( n )\n Generates a linearly spaced numeric array whose elements increment by 1\n starting from zero.\n\n If `n` is a non-integer value greater than zero, the function returns an\n array having `ceil(n)` elements.\n\n If `n` is less than or equal to zero, the function returns an empty array.\n\n Parameters\n ----------\n n: number\n Number of elements.\n\n Returns\n -------\n out: Array\n Linearly spaced numeric array.\n\n Examples\n --------\n > var arr = base.azeroTo( 6 )\n [ 0, 1, 2, 3, 4, 5 ]\n\n\nbase.azeroTo.assign( out, stride, offset )\n Fills an array with linearly spaced numeric elements which increment by 1\n starting from zero.\n\n Parameters\n ----------\n out: ArrayLikeObject\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = [ 0, 0, 0, 0, 0, 0 ];\n > base.azeroTo.assign( out, -1, out.length-1 );\n > out\n [ 5, 4, 3, 2, 1, 0 ]\n\n See Also\n --------\n base.aoneTo\n","base.azeroTo.assign":"\nbase.azeroTo.assign( out, stride, offset )\n Fills an array with linearly spaced numeric elements which increment by 1\n starting from zero.\n\n Parameters\n ----------\n out: ArrayLikeObject\n Output array.\n\n stride: integer\n Output array stride.\n\n offset: integer\n Output array index offset.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = [ 0, 0, 0, 0, 0, 0 ];\n > base.azeroTo.assign( out, -1, out.length-1 );\n > out\n [ 5, 4, 3, 2, 1, 0 ]\n\n See Also\n --------\n base.aoneTo","base.bernoulli":"\nbase.bernoulli( n )\n Computes the nth Bernoulli number.\n\n If not provided a nonnegative integer value, the function returns `NaN`.\n\n If provided `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Input value.\n\n Returns\n -------\n y: number\n Bernoulli number.\n\n Examples\n --------\n > var y = base.bernoulli( 0 )\n 1.0\n > y = base.bernoulli( 1 )\n 0.5\n > y = base.bernoulli( 2 )\n ~0.167\n > y = base.bernoulli( 3 )\n 0.0\n > y = base.bernoulli( 4 )\n ~-0.033\n > y = base.bernoulli( 5 )\n 0.0\n > y = base.bernoulli( 20 )\n ~-529.124\n > y = base.bernoulli( 260 )\n -Infinity\n > y = base.bernoulli( 262 )\n Infinity\n > y = base.bernoulli( NaN )\n NaN\n\n","base.besselj0":"\nbase.besselj0( x )\n Computes the Bessel function of the first kind of order zero.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.besselj0( 0.0 )\n 1.0\n > y = base.besselj0( 1.0 )\n ~0.765\n > y = base.besselj0( PINF )\n 0.0\n > y = base.besselj0( NINF )\n 0.0\n > y = base.besselj0( NaN )\n NaN\n\n See Also\n --------\n base.besselj1, base.bessely0, base.bessely1\n","base.besselj1":"\nbase.besselj1( x )\n Computes the Bessel function of the first kind of order one.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.besselj1( 0.0 )\n 0.0\n > y = base.besselj1( 1.0 )\n ~0.440\n > y = base.besselj1( PINF )\n 0.0\n > y = base.besselj1( NINF )\n 0.0\n > y = base.besselj1( NaN )\n NaN\n\n See Also\n --------\n base.besselj0, base.bessely0, base.bessely1\n","base.bessely0":"\nbase.bessely0( x )\n Computes the Bessel function of the second kind of order zero.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.bessely0( 0.0 )\n -Infinity\n > y = base.bessely0( 1.0 )\n ~0.088\n > y = base.bessely0( -1.0 )\n NaN\n > y = base.bessely0( PINF )\n 0.0\n > y = base.bessely0( NINF )\n NaN\n > y = base.bessely0( NaN )\n NaN\n\n See Also\n --------\n base.besselj0, base.besselj1, base.bessely1\n","base.bessely1":"\nbase.bessely1( x )\n Computes the Bessel function of the second kind of order one.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.bessely1( 0.0 )\n -Infinity\n > y = base.bessely1( 1.0 )\n ~-0.781\n > y = base.bessely1( -1.0 )\n NaN\n > y = base.bessely1( PINF )\n 0.0\n > y = base.bessely1( NINF )\n NaN\n > y = base.bessely1( NaN )\n NaN\n\n See Also\n --------\n base.besselj0, base.besselj1, base.bessely0\n","base.beta":"\nbase.beta( x, y )\n Evaluates the beta function.\n\n Parameters\n ----------\n x: number\n First function parameter (nonnegative).\n\n y: number\n Second function parameter (nonnegative).\n\n Returns\n -------\n out: number\n Evaluated beta function.\n\n Examples\n --------\n > var v = base.beta( 0.0, 0.5 )\n Infinity\n > v = base.beta( 1.0, 1.0 )\n 1.0\n > v = base.beta( -1.0, 2.0 )\n NaN\n > v = base.beta( 5.0, 0.2 )\n ~3.382\n > v = base.beta( 4.0, 1.0 )\n 0.25\n > v = base.beta( NaN, 2.0 )\n NaN\n\n See Also\n --------\n base.betainc, base.betaincinv, base.betaln\n","base.betainc":"\nbase.betainc( x, a, b[, regularized[, upper]] )\n Computes the regularized incomplete beta function.\n\n The `regularized` and `upper` parameters specify whether to evaluate the\n non-regularized and/or upper incomplete beta functions, respectively.\n\n If provided `x < 0` or `x > 1`, the function returns `NaN`.\n\n If provided `a < 0` or `b < 0`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n First function parameter.\n\n a: number\n Second function parameter.\n\n b: number\n Third function parameter.\n\n regularized: boolean (optional)\n Boolean indicating whether the function should evaluate the regularized\n or non-regularized incomplete beta function. Default: `true`.\n\n upper: boolean (optional)\n Boolean indicating whether the function should return the upper tail of\n the incomplete beta function. Default: `false`.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.betainc( 0.5, 2.0, 2.0 )\n 0.5\n > y = base.betainc( 0.5, 2.0, 2.0, false )\n ~0.083\n > y = base.betainc( 0.2, 1.0, 2.0 )\n 0.36\n > y = base.betainc( 0.2, 1.0, 2.0, true, true )\n 0.64\n > y = base.betainc( NaN, 1.0, 1.0 )\n NaN\n > y = base.betainc( 0.8, NaN, 1.0 )\n NaN\n > y = base.betainc( 0.8, 1.0, NaN )\n NaN\n > y = base.betainc( 1.5, 1.0, 1.0 )\n NaN\n > y = base.betainc( -0.5, 1.0, 1.0 )\n NaN\n > y = base.betainc( 0.5, -2.0, 2.0 )\n NaN\n > y = base.betainc( 0.5, 2.0, -2.0 )\n NaN\n\n See Also\n --------\n base.beta, base.betaincinv, base.betaln\n","base.betaincinv":"\nbase.betaincinv( p, a, b[, upper] )\n Computes the inverse of the lower incomplete beta function.\n\n In contrast to a more commonly used definition, the first argument is the\n probability `p` and the second and third arguments are `a` and `b`,\n respectively.\n\n By default, the function inverts the lower regularized incomplete beta\n function. To invert the upper function, set the `upper` argument to `true`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Probability.\n\n a: number\n Second function parameter.\n\n b: number\n Third function parameter.\n\n upper: boolean (optional)\n Boolean indicating if the function should invert the upper tail of the\n incomplete beta function. Default: `false`.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.betaincinv( 0.2, 3.0, 3.0 )\n ~0.327\n > y = base.betaincinv( 0.4, 3.0, 3.0 )\n ~0.446\n > y = base.betaincinv( 0.4, 3.0, 3.0, true )\n ~0.554\n > y = base.betaincinv( 0.4, 1.0, 6.0 )\n ~0.082\n > y = base.betaincinv( 0.8, 1.0, 6.0 )\n ~0.235\n > y = base.betaincinv( NaN, 1.0, 1.0 )\n NaN\n > y = base.betaincinv( 0.5, NaN, 1.0 )\n NaN\n > y = base.betaincinv( 0.5, 1.0, NaN )\n NaN\n > y = base.betaincinv( 1.2, 1.0, 1.0 )\n NaN\n > y = base.betaincinv( -0.5, 1.0, 1.0 )\n NaN\n > y = base.betaincinv( 0.5, -2.0, 2.0 )\n NaN\n > y = base.betaincinv( 0.5, 0.0, 2.0 )\n NaN\n > y = base.betaincinv( 0.5, 2.0, -2.0 )\n NaN\n > y = base.betaincinv( 0.5, 2.0, 0.0 )\n NaN\n\n See Also\n --------\n base.beta, base.betainc, base.betaln\n","base.betaln":"\nbase.betaln( a, b )\n Evaluates the natural logarithm of the beta function.\n\n Parameters\n ----------\n a: number\n First function parameter (nonnegative).\n\n b: number\n Second function parameter (nonnegative).\n\n Returns\n -------\n out: number\n Natural logarithm of the beta function.\n\n Examples\n --------\n > var v = base.betaln( 0.0, 0.0 )\n Infinity\n > v = base.betaln( 1.0, 1.0 )\n 0.0\n > v = base.betaln( -1.0, 2.0 )\n NaN\n > v = base.betaln( 5.0, 0.2 )\n ~1.218\n > v = base.betaln( 4.0, 1.0 )\n ~-1.386\n > v = base.betaln( NaN, 2.0 )\n NaN\n\n See Also\n --------\n base.beta, base.betainc, base.betaincinv\n","base.binet":"\nbase.binet( x )\n Evaluates Binet's formula extended to real numbers.\n\n If provided `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function result.\n\n Examples\n --------\n > var y = base.binet( 0.0 )\n 0.0\n > y = base.binet( 1.0 )\n 1.0\n > y = base.binet( 2.0 )\n 1.0\n > y = base.binet( 3.0 )\n 2.0\n > y = base.binet( 4.0 )\n 3.0\n > y = base.binet( 5.0 )\n ~5.0\n > y = base.binet( NaN )\n NaN\n\n See Also\n --------\n base.fibonacci, base.negafibonacci\n","base.binomcoef":"\nbase.binomcoef( n, k )\n Computes the binomial coefficient of two integers.\n\n If `k < 0`, the function returns `0`.\n\n The function returns `NaN` for non-integer `n` or `k`.\n\n Parameters\n ----------\n n: integer\n First input value.\n\n k: integer\n Second input value.\n\n Returns\n -------\n out: number\n Function value.\n\n Examples\n --------\n > var v = base.binomcoef( 8, 2 )\n 28\n > v = base.binomcoef( 0, 0 )\n 1\n > v = base.binomcoef( -4, 2 )\n 10\n > v = base.binomcoef( 5, 3 )\n 10\n > v = base.binomcoef( NaN, 3 )\n NaN\n > v = base.binomcoef( 5, NaN )\n NaN\n > v = base.binomcoef( NaN, NaN )\n NaN\n\n","base.binomcoefln":"\nbase.binomcoefln( n, k )\n Computes the natural logarithm of the binomial coefficient of two integers.\n\n If `k < 0`, the function returns negative infinity.\n\n The function returns `NaN` for non-integer `n` or `k`.\n\n Parameters\n ----------\n n: integer\n First input value.\n\n k: integer\n Second input value.\n\n Returns\n -------\n out: number\n Natural logarithm of the binomial coefficient.\n\n Examples\n --------\n > var v = base.binomcoefln( 8, 2 )\n ~3.332\n > v = base.binomcoefln( 0, 0 )\n 0.0\n > v = base.binomcoefln( -4, 2 )\n ~2.303\n > v = base.binomcoefln( 88, 3 )\n ~11.606\n > v = base.binomcoefln( NaN, 3 )\n NaN\n > v = base.binomcoefln( 5, NaN )\n NaN\n > v = base.binomcoefln( NaN, NaN )\n NaN\n\n","base.boxcox":"\nbase.boxcox( x, lambda )\n Computes a one-parameter Box-Cox transformation.\n\n Parameters\n ----------\n x: number\n Input value.\n\n lambda: number\n Power parameter.\n\n Returns\n -------\n b: number\n Function value.\n\n Examples\n --------\n > var v = base.boxcox( 1.0, 2.5 )\n 0.0\n > v = base.boxcox( 4.0, 2.5 )\n 12.4\n > v = base.boxcox( 10.0, 2.5 )\n ~126.0911\n > v = base.boxcox( 2.0, 0.0 )\n ~0.6931\n > v = base.boxcox( -1.0, 2.5 )\n NaN\n > v = base.boxcox( 0.0, -1.0 )\n -Infinity\n\n See Also\n --------\n base.boxcoxinv, base.boxcox1p, base.boxcox1pinv","base.boxcox1p":"\nbase.boxcox1p( x, lambda )\n Computes a one-parameter Box-Cox transformation of 1+x.\n\n Parameters\n ----------\n x: number\n Input value.\n\n lambda: number\n Power parameter.\n\n Returns\n -------\n b: number\n Function value.\n\n Examples\n --------\n > var v = base.boxcox1p( 1.0, 2.5 )\n ~1.8627\n > v = base.boxcox1p( 4.0, 2.5 )\n ~21.9607\n > v = base.boxcox1p( 10.0, 2.5 )\n ~160.1246\n > v = base.boxcox1p( 2.0, 0.0 )\n ~1.0986\n > v = base.boxcox1p( -1.0, 2.5 )\n -0.4\n > v = base.boxcox1p( 0.0, -1.0 )\n 0.0\n > v = base.boxcox1p( -1.0, -1.0 )\n -Infinity\n\n See Also\n --------\n base.boxcox, base.boxcox1pinv, base.boxcoxinv","base.boxcox1pinv":"\nbase.boxcox1pinv( y, lambda )\n Computes the inverse of a one-parameter Box-Cox transformation for 1+x.\n\n Parameters\n ----------\n y: number\n Input value.\n\n lambda: number\n Power parameter.\n\n Returns\n -------\n v: number\n Function value.\n\n Examples\n --------\n > var v = base.boxcox1pinv( 1.0, 2.5 )\n ~0.6505\n > v = base.boxcox1pinv( 4.0, 2.5 )\n ~1.6095\n > v = base.boxcox1pinv( 10.0, 2.5 )\n ~2.6812\n > v = base.boxcox1pinv( 2.0, 0.0 )\n ~6.3891\n > v = base.boxcox1pinv( -1.0, 2.5 )\n NaN\n > v = base.boxcox1pinv( 0.0, -1.0 )\n 0.0\n > v = base.boxcox1pinv( 1.0, NaN )\n NaN\n > v = base.boxcox1pinv( NaN, 3.1 )\n NaN\n\n See Also\n --------\n base.boxcox, base.boxcox1p, base.boxcoxinv","base.boxcoxinv":"\nbase.boxcoxinv( y, lambda )\n Computes the inverse of a one-parameter Box-Cox transformation.\n\n Parameters\n ----------\n y: number\n Input value.\n\n lambda: number\n Power parameter.\n\n Returns\n -------\n b: number\n Function value.\n\n Examples\n --------\n > var v = base.boxcoxinv( 1.0, 2.5 )\n ~1.6505\n > v = base.boxcoxinv( 4.0, 2.5 )\n ~2.6095\n > v = base.boxcoxinv( 10.0, 2.5 )\n ~3.6812\n > v = base.boxcoxinv( 2.0, 0.0 )\n ~7.3891\n > v = base.boxcoxinv( -1.0, 2.5 )\n NaN\n > v = base.boxcoxinv( 0.0, -1.0 )\n 1.0\n > v = base.boxcoxinv( 1.0, NaN )\n NaN\n > v = base.boxcoxinv( NaN, 3.1 )\n NaN\n\n See Also\n --------\n base.boxcox, base.boxcox1p, base.boxcox1pinv","base.cabs":"\nbase.cabs( z )\n Computes the absolute value of a double-precision complex floating-point\n number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n y: number\n Absolute value.\n\n Examples\n --------\n > var y = base.cabs( new Complex128( 5.0, 3.0 ) )\n ~5.831\n\n See Also\n --------\n base.cabs2, base.abs\n","base.cabs2":"\nbase.cabs2( z )\n Computes the squared absolute value of a double-precision complex floating-\n point number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n y: number\n Squared absolute value.\n\n Examples\n --------\n > var y = base.cabs2( new Complex128( 5.0, 3.0 ) )\n 34.0\n\n See Also\n --------\n base.cabs, base.abs2\n","base.cabs2f":"\nbase.cabs2f( z )\n Computes the squared absolute value of a single-precision complex floating-\n point number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n z: Complex64\n Complex number.\n\n Returns\n -------\n y: number\n Squared absolute value.\n\n Examples\n --------\n > var y = base.cabs2f( new Complex64( 5.0, 3.0 ) )\n 34.0\n\n See Also\n --------\n base.cabs2, base.cabsf, base.abs2f\n","base.cabsf":"\nbase.cabsf( z )\n Computes the absolute value of a single-precision complex floating-point\n number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n z: Complex64\n Complex number.\n\n Returns\n -------\n y: number\n Absolute value.\n\n Examples\n --------\n > var y = base.cabsf( new Complex64( 5.0, 3.0 ) )\n ~5.831\n\n See Also\n --------\n base.cabs, base.cabs2f, base.absf\n","base.cadd":"\nbase.cadd( z1, z2 )\n Adds two double-precision complex floating-point numbers.\n\n Parameters\n ----------\n z1: Complex128\n Complex number.\n\n z2: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var z = new Complex128( 5.0, 3.0 )\n \n > var out = base.cadd( z, z )\n \n > var re = real( out )\n 10.0\n > var im = imag( out )\n 6.0\n\n\nbase.cadd.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Adds two double-precision complex floating-point numbers and assigns results\n to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cadd.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n\nbase.cadd.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Adds two double-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ 5.0, 3.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cadd.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n See Also\n --------\n base.cdiv, base.cmul, base.csub\n","base.cadd.assign":"\nbase.cadd.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Adds two double-precision complex floating-point numbers and assigns results\n to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cadd.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ 3.0, 4.0 ]","base.cadd.strided":"\nbase.cadd.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Adds two double-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ 5.0, 3.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cadd.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n See Also\n --------\n base.cdiv, base.cmul, base.csub","base.caddf":"\nbase.caddf( z1, z2 )\n Adds two single-precision complex floating-point numbers.\n\n Parameters\n ----------\n z1: Complex64\n Complex number.\n\n z2: Complex64\n Complex number.\n\n Returns\n -------\n out: Complex64\n Result.\n\n Examples\n --------\n > var z = new Complex64( 5.0, 3.0 )\n \n > var out = base.caddf( z, z )\n \n > var re = realf( out )\n 10.0\n > var im = imagf( out )\n 6.0\n\n\nbase.caddf.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Adds two single-precision complex floating-point numbers and assigns results\n to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float32Array( 2 );\n > base.caddf.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n\nbase.caddf.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Adds two single-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float32Array( [ 5.0, 3.0 ] );\n > var z2 = new Float32Array( [ -2.0, 1.0 ] );\n > var out = new Float32Array( 2 );\n > base.caddf.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n See Also\n --------\n base.cadd, base.cmulf, base.csubf\n","base.caddf.assign":"\nbase.caddf.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Adds two single-precision complex floating-point numbers and assigns results\n to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float32Array( 2 );\n > base.caddf.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ 3.0, 4.0 ]","base.caddf.strided":"\nbase.caddf.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Adds two single-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float32Array( [ 5.0, 3.0 ] );\n > var z2 = new Float32Array( [ -2.0, 1.0 ] );\n > var out = new Float32Array( 2 );\n > base.caddf.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 3.0, 4.0 ]\n\n See Also\n --------\n base.cadd, base.cmulf, base.csubf","base.camelcase":"\nbase.camelcase( str )\n Converts a string to camel case.\n\n Parameters\n ----------\n str: string\n Input string.\n\n Returns\n -------\n out: string\n Camel-cased string.\n\n Examples\n --------\n > var out = base.camelcase( 'Hello World!' )\n 'helloWorld'\n > out = base.camelcase( 'beep boop' )\n 'beepBoop'\n\n See Also\n --------\n base.constantcase, base.lowercase, base.snakecase, base.uppercase","base.capitalize":"\nbase.capitalize( str )\n Capitalizes the first character in a string.\n\n Parameters\n ----------\n str: string\n Input string.\n\n Returns\n -------\n out: string\n Capitalized string.\n\n Examples\n --------\n > var out = base.capitalize( 'beep' )\n 'Beep'\n > out = base.capitalize( 'Boop' )\n 'Boop'\n\n See Also\n --------\n base.lowercase, base.uppercase\n","base.cbrt":"\nbase.cbrt( x )\n Computes the cube root of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Cube root.\n\n Examples\n --------\n > var y = base.cbrt( 64.0 )\n 4.0\n > y = base.cbrt( 27.0 )\n 3.0\n > y = base.cbrt( 0.0 )\n 0.0\n > y = base.cbrt( -0.0 )\n -0.0\n > y = base.cbrt( -9.0 )\n ~-2.08\n > y = base.cbrt( NaN )\n NaN\n\n See Also\n --------\n base.pow, base.sqrt\n","base.cbrtf":"\nbase.cbrtf( x )\n Computes the cube root of a single-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Cube root.\n\n Examples\n --------\n > var y = base.cbrtf( 64.0 )\n 4.0\n > y = base.cbrtf( 27.0 )\n 3.0\n > y = base.cbrtf( 0.0 )\n 0.0\n > y = base.cbrtf( -0.0 )\n -0.0\n > y = base.cbrtf( -9.0 )\n ~-2.08\n > y = base.cbrtf( NaN )\n NaN\n\n See Also\n --------\n base.cbrt, base.sqrtf\n","base.cceil":"\nbase.cceil( z )\n Rounds each component of a double-precision complex floating-point number\n toward positive infinity.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var v = base.cceil( new Complex128( -1.5, 2.5 ) )\n \n > var re = real( v )\n -1.0\n > var im = imag( v )\n 3.0\n\n See Also\n --------\n base.cceiln, base.cfloor, base.cround\n","base.cceilf":"\nbase.cceilf( z )\n Rounds each component of a single-precision complex floating-point number\n toward positive infinity.\n\n Parameters\n ----------\n z: Complex64\n Complex number.\n\n Returns\n -------\n out: Complex64\n Result.\n\n Examples\n --------\n > var v = base.cceilf( new Complex64( -1.5, 2.5 ) )\n \n > var re = realf( v )\n -1.0\n > var im = imagf( v )\n 3.0\n\n See Also\n --------\n base.cceil\n","base.cceiln":"\nbase.cceiln( z, n )\n Rounds each component of a double-precision complex number to the nearest\n multiple of `10^n` toward positive infinity.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n out: Complex128\n Real and imaginary components.\n\n Examples\n --------\n > var out = base.cceiln( new Complex128( 5.555, -3.333 ), -2 )\n \n > var re = real( out )\n 5.56\n > var im = imag( out )\n -3.33\n\n See Also\n --------\n base.cceil, base.cfloorn, base.croundn\n","base.ccis":"\nbase.ccis( z )\n Evaluates the cis function for a double-precision complex floating-point\n number.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Complex number.\n\n Examples\n --------\n > var y = base.ccis( new Complex128( 0.0, 0.0 ) )\n \n > var re = real( y )\n 1.0\n > var im = imag( y )\n 0.0\n > y = base.ccis( new Complex128( 1.0, 0.0 ) )\n \n > re = real( y )\n ~0.540\n > im = imag( y )\n ~0.841\n\n","base.cdiv":"\nbase.cdiv( z1, z2 )\n Divides two double-precision complex floating-point numbers.\n\n Parameters\n ----------\n z1: Complex128\n Complex number.\n\n z2: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var z1 = new Complex128( -13.0, -1.0 )\n \n > var z2 = new Complex128( -2.0, 1.0 )\n \n > var y = base.cdiv( z1, z2 )\n \n > var re = real( y )\n 5.0\n > var im = imag( y )\n 3.0\n\n\nbase.cdiv.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Divides two double-precision complex floating-point numbers and assigns\n results to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cdiv.assign( -13.0, -1.0, -2.0, 1.0, out, 1, 0 )\n [ 5.0, 3.0 ]\n\n\nbase.cdiv.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Divides two double-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ -13.0, -1.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cdiv.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 5.0, 3.0 ]\n\n See Also\n --------\n base.cadd, base.cmul, base.csub","base.cdiv.assign":"\nbase.cdiv.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Divides two double-precision complex floating-point numbers and assigns\n results to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cdiv.assign( -13.0, -1.0, -2.0, 1.0, out, 1, 0 )\n [ 5.0, 3.0 ]","base.cdiv.strided":"\nbase.cdiv.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Divides two double-precision complex floating-point numbers stored in real-\n valued strided array views and assigns results to a provided strided output\n array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ -13.0, -1.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cdiv.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ 5.0, 3.0 ]\n\n See Also\n --------\n base.cadd, base.cmul, base.csub","base.ceil":"\nbase.ceil( x )\n Rounds a double-precision floating-point number toward positive infinity.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceil( 3.14 )\n 4.0\n > y = base.ceil( -4.2 )\n -4.0\n > y = base.ceil( -4.6 )\n -4.0\n > y = base.ceil( 9.5 )\n 10.0\n > y = base.ceil( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceiln, base.floor, base.round\n","base.ceil2":"\nbase.ceil2( x )\n Rounds a numeric value to the nearest power of two toward positive infinity.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceil2( 3.14 )\n 4.0\n > y = base.ceil2( -4.2 )\n -4.0\n > y = base.ceil2( -4.6 )\n -4.0\n > y = base.ceil2( 9.5 )\n 16.0\n > y = base.ceil2( 13.0 )\n 16.0\n > y = base.ceil2( -13.0 )\n -8.0\n > y = base.ceil2( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceil, base.ceil10, base.floor2, base.round2\n","base.ceil10":"\nbase.ceil10( x )\n Rounds a numeric value to the nearest power of ten toward positive infinity.\n\n The function may not return accurate results for subnormals due to a general\n loss in precision.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceil10( 3.14 )\n 10.0\n > y = base.ceil10( -4.2 )\n -1.0\n > y = base.ceil10( -4.6 )\n -1.0\n > y = base.ceil10( 9.5 )\n 10.0\n > y = base.ceil10( 13.0 )\n 100.0\n > y = base.ceil10( -13.0 )\n -10.0\n > y = base.ceil10( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceil, base.ceil2, base.floor10, base.round10\n","base.ceilb":"\nbase.ceilb( x, n, b )\n Rounds a numeric value to the nearest multiple of `b^n` toward positive\n infinity.\n\n Due to floating-point rounding error, rounding may not be exact.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Integer power.\n\n b: integer\n Base.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n // Round to 4 decimal places:\n > var y = base.ceilb( 3.14159, -4, 10 )\n 3.1416\n\n // If `n = 0` or `b = 1`, standard round behavior:\n > y = base.ceilb( 3.14159, 0, 2 )\n 4.0\n\n // Round to nearest multiple of two toward positive infinity:\n > y = base.ceilb( 5.0, 1, 2 )\n 6.0\n\n See Also\n --------\n base.ceil, base.ceiln, base.floorb, base.roundb\n","base.ceilf":"\nbase.ceilf( x )\n Rounds a single-precision floating-point number toward positive infinity.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceilf( 3.14 )\n 4.0\n > y = base.ceilf( -4.2 )\n -4.0\n > y = base.ceilf( -4.6 )\n -4.0\n > y = base.ceilf( 9.5 )\n 10.0\n > y = base.ceilf( -0.0 )\n -0.0\n\n See Also\n --------\n base.floorf\n","base.ceiln":"\nbase.ceiln( x, n )\n Rounds a numeric value to the nearest multiple of `10^n` toward positive\n infinity.\n\n When operating on floating-point numbers in bases other than `2`, rounding\n to specified digits can be inexact.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n // Round to 2 decimal places:\n > var y = base.ceiln( 3.14159, -2 )\n 3.15\n\n // If `n = 0`, standard round toward positive infinity behavior:\n > y = base.ceiln( 3.14159, 0 )\n 4.0\n\n // Round to nearest thousand:\n > y = base.ceiln( 12368.0, 3 )\n 13000.0\n\n\n See Also\n --------\n base.ceil, base.ceilb, base.floorn, base.roundn\n","base.ceilsd":"\nbase.ceilsd( x, n, b )\n Rounds a numeric value to the nearest number toward positive infinity with\n `n` significant figures.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Number of significant figures. Must be greater than 0.\n\n b: integer\n Base. Must be greater than 0.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceilsd( 3.14159, 5, 10 )\n 3.1416\n > y = base.ceilsd( 3.14159, 1, 10 )\n 4.0\n > y = base.ceilsd( 12368.0, 2, 10 )\n 13000.0\n > y = base.ceilsd( 0.0313, 2, 2 )\n 0.046875\n\n See Also\n --------\n base.ceil, base.floorsd, base.roundsd, base.truncsd\n","base.cexp":"\nbase.cexp( z )\n Evaluates the exponential function for a double-precision complex floating-\n point number.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Complex number.\n\n Examples\n --------\n > var y = base.cexp( new Complex128( 0.0, 0.0 ) )\n \n > var re = real( y )\n 1.0\n > var im = imag( y )\n 0.0\n > y = base.cexp( new Complex128( 0.0, 1.0 ) )\n \n > re = real( y )\n ~0.540\n > im = imag( y )\n ~0.841\n\n","base.cflipsign":"\nbase.cflipsign( z, y )\n Returns a double-precision complex floating-point number with the same\n magnitude as `z` and the sign of `y*z`.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n y: number\n Number from which to derive the sign.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var v = base.cflipsign( new Complex128( -4.2, 5.5 ), -9.0 )\n \n > var re = real( v )\n 4.2\n > var im = imag( v )\n -5.5\n\n See Also\n --------\n base.cneg, base.csignum\n","base.cflipsignf":"\nbase.cflipsignf( z, y )\n Returns a single-precision complex floating-point number with the same\n magnitude as `z` and the sign of `y*z`.\n\n Parameters\n ----------\n z: Complex64\n Complex number.\n\n y: number\n Number from which to derive the sign.\n\n Returns\n -------\n out: Complex64\n Result.\n\n Examples\n --------\n > var v = base.cflipsignf( new Complex64( -4.0, 5.0 ), -9.0 )\n \n > var re = realf( v )\n 4.0\n > var im = imagf( v )\n -5.0\n\n See Also\n --------\n base.cnegf, base.cflipsign\n","base.cfloor":"\nbase.cfloor( z )\n Rounds a double-precision complex floating-point number toward negative\n infinity.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var v = base.cfloor( new Complex128( 5.5, 3.3 ) )\n \n > var re = real( v )\n 5.0\n > var im = imag( v )\n 3.0\n\n See Also\n --------\n base.cceil, base.cfloorn, base.cround\n","base.cfloorn":"\nbase.cfloorn( z, n )\n Rounds each component of a double-precision complex floating-point number\n to the nearest multiple of `10^n` toward negative infinity.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n z: Complex128\n Result.\n\n Examples\n --------\n > var v = base.cfloorn( new Complex128( 5.555, -3.333 ), -2 )\n \n > var re = real( v )\n 5.55\n > var im = imag( v )\n -3.34\n\n See Also\n --------\n base.cceiln, base.cfloor, base.croundn\n","base.cidentity":"\nbase.cidentity( z )\n Evaluates the identity function for a double-precision complex floating-\n point number.\n\n Parameters\n ----------\n z: Complex128\n Input value.\n\n Returns\n -------\n v: Complex128\n Input value.\n\n Examples\n --------\n > var v = base.cidentity( new Complex128( -1.0, 2.0 ) )\n \n > var re = real( v )\n -1.0\n > var img = imag( v )\n 2.0\n\n See Also\n --------\n base.cidentityf, base.identity\n","base.cidentityf":"\nbase.cidentityf( z )\n Evaluates the identity function for a single-precision complex floating-\n point number.\n\n Parameters\n ----------\n z: Complex64\n Input value.\n\n Returns\n -------\n v: Complex64\n Input value.\n\n Examples\n --------\n > var v = base.cidentityf( new Complex64( -1.0, 2.0 ) )\n \n > var re = realf( v )\n -1.0\n > var img = imagf( v )\n 2.0\n\n See Also\n --------\n base.cidentity, base.identityf\n","base.cinv":"\nbase.cinv( z )\n Computes the inverse of a double-precision complex floating-point number.\n\n Parameters\n ----------\n z: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var v = base.cinv( new Complex128( 2.0, 4.0 ) )\n \n > var re = real( v )\n 0.1\n > var im = imag( v )\n -0.2\n\n See Also\n --------\n base.cdiv, base.cinvf\n","base.cinvf":"\nbase.cinvf( z )\n Computes the inverse of a single-precision complex floating-point number.\n\n Parameters\n ----------\n z: Complex64\n Complex number.\n\n Returns\n -------\n out: Complex64\n Result.\n\n Examples\n --------\n > var v = base.cinvf( new Complex64( 2.0, 4.0 ) )\n \n > var re = realf( v )\n ~0.1\n > var im = imagf( v )\n ~-0.2\n\n See Also\n --------\n base.cinv\n","base.clamp":"\nbase.clamp( v, min, max )\n Restricts a double-precision floating-point number to a specified range.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Value to restrict.\n\n min: number\n Minimum value.\n\n max: number\n Maximum value.\n\n Returns\n -------\n y: number\n Restricted value.\n\n Examples\n --------\n > var y = base.clamp( 3.14, 0.0, 5.0 )\n 3.14\n > y = base.clamp( -3.14, 0.0, 5.0 )\n 0.0\n > y = base.clamp( 3.14, 0.0, 3.0 )\n 3.0\n > y = base.clamp( -0.0, 0.0, 5.0 )\n 0.0\n > y = base.clamp( 0.0, -3.14, -0.0 )\n -0.0\n > y = base.clamp( NaN, 0.0, 5.0 )\n NaN\n\n See Also\n --------\n base.clampf, base.wrap\n","base.clampf":"\nbase.clampf( v, min, max )\n Restricts a single-precision floating-point number to a specified range.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Value to restrict.\n\n min: number\n Minimum value.\n\n max: number\n Maximum value.\n\n Returns\n -------\n y: number\n Restricted value.\n\n Examples\n --------\n > var y = base.clampf( 3.14, 0.0, 5.0 )\n 3.14\n > y = base.clampf( -3.14, 0.0, 5.0 )\n 0.0\n > y = base.clampf( 3.14, 0.0, 3.0 )\n 3.0\n > y = base.clampf( -0.0, 0.0, 5.0 )\n 0.0\n > y = base.clampf( 0.0, -3.14, -0.0 )\n -0.0\n > y = base.clampf( NaN, 0.0, 5.0 )\n NaN\n\n See Also\n --------\n base.clamp\n","base.cmul":"\nbase.cmul( z1, z2 )\n Multiplies two double-precision complex floating-point numbers.\n\n Parameters\n ----------\n z1: Complex128\n Complex number.\n\n z2: Complex128\n Complex number.\n\n Returns\n -------\n out: Complex128\n Result.\n\n Examples\n --------\n > var z1 = new Complex128( 5.0, 3.0 )\n \n > var z2 = new Complex128( -2.0, 1.0 )\n \n > var out = base.cmul( z1, z2 )\n \n > var re = real( out )\n -13.0\n > var im = imag( out )\n -1.0\n\n\nbase.cmul.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Multiplies two double-precision complex floating-point numbers and assigns\n results to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cmul.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ -13.0, -1.0 ]\n\n\nbase.cmul.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Multiplies two double-precision complex floating-point numbers stored in\n real-valued strided array views and assigns results to a provided strided\n output array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ 5.0, 3.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cmul.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n [ -13.0, -1.0 ]\n\n See Also\n --------\n base.cadd, base.cdiv, base.csub\n","base.cmul.assign":"\nbase.cmul.assign( re1, im1, re2, im2, out, strideOut, offsetOut )\n Multiplies two double-precision complex floating-point numbers and assigns\n results to a provided output array.\n\n Parameters\n ----------\n re1: number\n Real component of the first complex number.\n\n im1: number\n Imaginary component of the first complex number.\n\n re2: number\n Real component of the second complex number.\n\n im2: number\n Imaginary component of the second complex number.\n\n out: ArrayLikeObject\n Output array.\n\n strideOut: integer\n Stride length.\n\n offsetOut: integer\n Starting index.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var out = new Float64Array( 2 );\n > base.cmul.assign( 5.0, 3.0, -2.0, 1.0, out, 1, 0 )\n [ -13.0, -1.0 ]","base.cmul.strided":"\nbase.cmul.strided( z1, sz1, oz1, z2, sz2, oz2, out, so, oo )\n Multiplies two double-precision complex floating-point numbers stored in\n real-valued strided array views and assigns results to a provided strided\n output array.\n\n Parameters\n ----------\n z1: ArrayLikeObject\n First complex number view.\n\n sz1: integer\n Stride length for `z1`.\n\n oz1: integer\n Starting index for `z1`.\n\n z2: ArrayLikeObject\n Second complex number view.\n\n sz2: integer\n Stride length for `z2`.\n\n oz2: integer\n Starting index for `z2`.\n\n out: ArrayLikeObject\n Output array.\n\n so: integer\n Stride length for `out`.\n\n oo: integer\n Starting index for `out`.\n\n Returns\n -------\n out: ArrayLikeObject\n Output array.\n\n Examples\n --------\n > var z1 = new Float64Array( [ 5.0, 3.0 ] );\n > var z2 = new Float64Array( [ -2.0, 1.0 ] );\n > var out = new Float64Array( 2 );\n > base.cmul.strided( z1, 1, 0, z2, 1, 0, out, 1, 0 )\n