diff --git a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/lib/runner.js b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/lib/runner.js
index 3d9feafddef8..fe9e7e41a2f4 100644
--- a/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/lib/runner.js
+++ b/lib/node_modules/@stdlib/_tools/remark/plugins/remark-run-javascript-examples/lib/runner.js
@@ -219,7 +219,7 @@ function factory( options ) {
if ( UFLG ) {
if ( FIRST === null ) {
debug( 'Caching block contents...' );
- FIRST = script;
+ FIRST = '"use strict";\n\n' + script;
} else {
// Prepend the first block to all subsequent code blocks:
script = FIRST + '\n\n' + script;
diff --git a/lib/node_modules/@stdlib/_tools/repl-txt/rules/doctest/lib/main.js b/lib/node_modules/@stdlib/_tools/repl-txt/rules/doctest/lib/main.js
index 22d09b5f2e79..f8e70e2ecb6c 100644
--- a/lib/node_modules/@stdlib/_tools/repl-txt/rules/doctest/lib/main.js
+++ b/lib/node_modules/@stdlib/_tools/repl-txt/rules/doctest/lib/main.js
@@ -24,14 +24,14 @@ var vm = require( 'vm' );
var dirname = require( 'path' ).dirname;
var replace = require( '@stdlib/string/replace' );
var namespace = require( '@stdlib/namespace' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
var compareValues = require( '@stdlib/_tools/doctest/compare-values' );
// VARIABLES //
-var RE_OUTSIDE_ALIAS = /{{alias:([\s\S]+?)}}/g;
+var RE_EXTERNAL_ALIAS = /{{alias:([\s\S]+?)}}/g;
var RE_ASSIGNMENT = /(?:var|let|const)? ?([a-zA-Z0-9]*) ?=/;
-var RE_DOT = /\.([a-z])/gi;
var NAMESPACE = namespace();
@@ -51,7 +51,6 @@ function pkg2alias( pkg ) {
for ( i = 0; i < NAMESPACE.length; i++ ) {
if ( pkg === NAMESPACE[ i ].path ) {
alias = NAMESPACE[ i ].alias;
- alias = replace( alias, RE_DOT, '$1' );
return alias;
}
}
@@ -90,6 +89,8 @@ function main( context ) {
var b;
var i;
+ // FIXME: clean-up this logic
+
if ( context.meta.filepath ) {
expected = [];
actual = [];
@@ -100,15 +101,27 @@ function main( context ) {
'require': require
};
pkgName = pkg2alias( pkg ) || 'ALIAS';
- scope[ pkgName ] = require( pkg ); // eslint-disable-line stdlib/no-dynamic-require
+
+ // TODO: move unflattening logic to utility function
+ pkgName = pkgName.split( '.' );
+ for ( i = 0; i < pkgName.length; i++ ) {
+ if ( i < pkgName.length-1 ) {
+ if ( !hasOwnProp( scope, pkgName[i] ) ) {
+ scope[ pkgName[i] ] = {};
+ }
+ } else {
+ scope[ pkgName[i] ] = require( pkg ); // eslint-disable-line stdlib/no-dynamic-require
+ }
+ }
+ // TODO: process external aliases *BEFORE* creating the context (and also, what is going on here, given that the return value is ignored?)
vm.createContext( scope );
examples = section.examples;
for ( i = 0; i < examples.length; i++ ) {
current = examples[ i ];
code = current.code;
- code = replace( code, '{{alias}}', pkgName );
- code = replace( code, RE_OUTSIDE_ALIAS, replaceAliases );
+ code = replace( code, '{{alias}}', pkgName.join( '.' ) );
+ code = replace( code, RE_EXTERNAL_ALIAS, replaceAliases );
try {
out = vm.runInContext( code, scope );
if ( current.output ) {
@@ -137,7 +150,7 @@ function main( context ) {
}
/**
- * Replaces aliases to other packages in REPL example code, while registering the respective packages in the `scope` of the generated function.
+ * Replaces aliases to other packages in REPL example code and registers the respective packages in the runtime context.
*
* @private
* @param {string} match - full match
@@ -146,8 +159,19 @@ function main( context ) {
*/
function replaceAliases( match, pkg ) {
var alias = pkg2alias( pkg );
- scope[ alias ] = require( pkg ); // eslint-disable-line stdlib/no-dynamic-require
- return alias;
+
+ // TODO: move unflattening logic to utility function
+ alias = alias.split( '.' );
+ for ( i = 0; i < alias.length; i++ ) {
+ if ( i < alias.length-1 ) {
+ if ( !hasOwnProp( scope, alias[i] ) ) {
+ scope[ alias[i] ] = {};
+ }
+ } else {
+ scope[ alias[i] ] = require( pkg ); // eslint-disable-line stdlib/no-dynamic-require
+ }
+ }
+ return alias.join( '.' );
}
}
diff --git a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/lib/compile.js b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/lib/compile.js
index d1fd77012fd7..52210493ce26 100644
--- a/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/lib/compile.js
+++ b/lib/node_modules/@stdlib/_tools/test-cov/tape-istanbul/lib/compile.js
@@ -38,21 +38,21 @@ function compile( filename, code ) {
var script;
var opts;
- // Set the `vm` options:
- opts = {
- 'filename': filename,
- 'lineOffset': 0,
- 'displayErrors': true
- };
-
// Wrap the source code similar to `require`:
code = wrap( code );
// Compile the source code:
+ opts = {
+ 'filename': filename,
+ 'lineOffset': 0
+ };
script = new vm.Script( code, opts );
// Run the compiled code in the current V8 context to generate a wrapped function:
- return script.runInThisContext();
+ opts = {
+ 'displayErrors': true
+ };
+ return script.runInThisContext( opts );
}
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/index.d.ts
new file mode 100644
index 000000000000..ce943cff105a
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/index.d.ts
@@ -0,0 +1,119 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Interface defining `isAbsolutePath` with methods for testing POSIX and Windows paths, respectively.
+*/
+interface IsAbsolutePath {
+ /**
+ * Tests if a value is an absolute path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is an absolute path
+ *
+ * @example
+ * var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+ * var bool;
+ * if ( IS_WINDOWS ) {
+ * bool = isAbsolutePath( 'C:\\foo\\bar\\baz' );
+ * // returns true
+ * } else {
+ * bool = isAbsolutePath( '/foo/bar/baz' );
+ * // returns true
+ * }
+ */
+ ( value: any ): boolean;
+
+ /**
+ * Tests if a value is a POSIX absolute path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a POSIX absolute path
+ *
+ * @example
+ * var bool = isAbsolutePath.posix( '/foo/bar/baz' );
+ * // returns true
+ *
+ * @example
+ * var bool = isAbsolutePath.posix( 'foo/bar/baz' );
+ * // returns false
+ */
+ posix( value: any ): boolean;
+
+ /**
+ * Tests if a value is a Windows absolute path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a Windows absolute path
+ *
+ * @example
+ * var bool = isAbsolutePath.win32( 'C:\\foo\\bar\\baz' );
+ * // returns true
+ *
+ * @example
+ * var bool = isAbsolutePath.win32( 'foo\\bar\\baz' );
+ * // returns false
+ */
+ win32( value: any ): boolean;
+}
+
+/**
+* Tests if a value is an absolute path.
+*
+* ## Notes
+*
+* - Function behavior is platform-specific. On Windows platforms, the function is equal to `.win32()`. On POSIX platforms, the function is equal to `.posix()`.
+*
+* @param value - value to test
+* @returns boolean indicating whether value is an absolute path
+*
+* @example
+* var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+* var bool;
+* if ( IS_WINDOWS ) {
+* bool = isAbsolutePath( 'C:\\foo\\bar\\baz' );
+* // returns true
+* } else {
+* bool = isAbsolutePath( '/foo/bar/baz' );
+* // returns true
+* }
+*
+* @example
+* var bool = isAbsolutePath.posix( '/foo/bar/baz' );
+* // returns true
+*
+* @example
+* var bool = isAbsolutePath.posix( 'foo/bar/baz' );
+* // returns false
+*
+* @example
+* var bool = isAbsolutePath.win32( 'C:\\foo\\bar\\baz' );
+* // returns true
+*
+* @example
+* var bool = isAbsolutePath.win32( 'foo\\bar\\baz' );
+* // returns false
+*/
+declare var isAbsolutePath: IsAbsolutePath;
+
+
+// EXPORTS //
+
+export = isAbsolutePath;
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/test.ts
new file mode 100644
index 000000000000..74270c3e5c40
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/docs/types/test.ts
@@ -0,0 +1,58 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isAbsolutePath = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isAbsolutePath( 'C:\\foo\\bar\\baz' ); // $ExpectType boolean
+ isAbsolutePath( '/foo/bar/baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isAbsolutePath(); // $ExpectError
+ isAbsolutePath( 'C:\\foo\\bar\\baz', 123 ); // $ExpectError
+}
+
+// Attached to main export is a `posix` method which returns a boolean...
+{
+ isAbsolutePath.posix( '/foo/bar/baz' ); // $ExpectType boolean
+ isAbsolutePath.posix( '/foo/../bar/baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `posix` method is provided an unsupported number of arguments...
+{
+ isAbsolutePath.posix(); // $ExpectError
+ isAbsolutePath.posix( '/foo/../bar/baz', 123 ); // $ExpectError
+}
+
+// Attached to main export is a `win32` method which returns a boolean...
+{
+ isAbsolutePath.win32( 'foo\\bar\\baz' ); // $ExpectType boolean
+ isAbsolutePath.win32( 'C:\\foo\\..\\bar\\baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `win32` method is provided an unsupported number of arguments...
+{
+ isAbsolutePath.win32(); // $ExpectError
+ isAbsolutePath.win32( 'C:\\foo\\..\\bar\\baz', 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-absolute-path/package.json b/lib/node_modules/@stdlib/assert/is-absolute-path/package.json
index 80852ecbbe8b..4b7fabbd832d 100644
--- a/lib/node_modules/@stdlib/assert/is-absolute-path/package.json
+++ b/lib/node_modules/@stdlib/assert/is-absolute-path/package.json
@@ -25,6 +25,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/index.d.ts
new file mode 100644
index 000000000000..ec1e48a8a054
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/index.d.ts
@@ -0,0 +1,125 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Interface defining `isFiniteArray` with methods for testing for primitive and object arrays, respectively.
+*/
+interface IsFiniteArray {
+ /**
+ * Tests if a value is an array-like object of finite numbers.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether a value is an array-like object of finite numbers
+ *
+ * @example
+ * var bool = isFiniteArray( [ -3.0, new Number(0.0), 2.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isFiniteArray( [ -3.0, 1.0/0.0 ] );
+ * // returns false
+ */
+ ( value: any ): boolean;
+
+ /**
+ * Tests if a value is an array-like object containing only primitive finite numbers.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether a value is an array-like object containing only primitive finite numbers
+ *
+ * @example
+ * var bool = isFiniteArray.primitives( [ -1.0, 10.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isFiniteArray.primitives( [ -1.5, 0.0, 5.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isFiniteArray.primitives( [ -3.0, new Number(-1.0) ] );
+ * // returns false
+ */
+ primitives( value: any ): boolean;
+
+ /**
+ * Tests if a value is an array-like object containing only number objects having finite values.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether a value is an array-like object containing only number objects having finite values
+ *
+ * @example
+ * var bool = isFiniteArray.objects( [ new Number(1.0), new Number(3.0) ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isFiniteArray.objects( [ -1.0, 0.0, 3.0 ] );
+ * // returns false
+ *
+ * @example
+ * var bool = isFiniteArray.objects( [ 3.0, new Number(-1.0) ] );
+ * // returns false
+ */
+ objects( value: any ): boolean;
+}
+
+/**
+* Tests if a value is an array-like object of finite numbers.
+*
+* @param value - value to test
+* @returns boolean indicating whether a value is an array-like object of finite numbers
+*
+* @example
+* var bool = isFiniteArray( [ -3.0, new Number(0.0), 2.0 ] );
+* // returns true
+*
+* @example
+* var bool = isFiniteArray( [ -3.0, 1.0/0.0 ] );
+* // returns false
+*
+* @example
+* var bool = isFiniteArray.primitives( [ -1.0, 10.0 ] );
+* // returns true
+*
+* @example
+* var bool = isFiniteArray.primitives( [ -1.5, 0.0, 5.0 ] );
+* // returns true
+*
+* @example
+* var bool = isFiniteArray.primitives( [ -3.0, new Number(-1.0) ] );
+* // returns false
+*
+* @example
+* var bool = isFiniteArray.objects( [ new Number(1.0), new Number(3.0) ] );
+* // returns true
+*
+* @example
+* var bool = isFiniteArray.objects( [ -1.0, 0.0, 3.0 ] );
+* // returns false
+*
+* @example
+* var bool = isFiniteArray.objects( [ 3.0, new Number(-1.0) ] );
+* // returns false
+*/
+declare var isFiniteArray: IsFiniteArray;
+
+
+// EXPORTS //
+
+export = isFiniteArray;
diff --git a/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/test.ts
new file mode 100644
index 000000000000..c28f3cdb65df
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-finite-array/docs/types/test.ts
@@ -0,0 +1,61 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isFiniteArray = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isFiniteArray( [ 4 ] ); // $ExpectType boolean
+ isFiniteArray( [ 2.8, 1 / 0 ] ); // $ExpectType boolean
+ isFiniteArray( [ '2.8' ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isFiniteArray(); // $ExpectError
+ isFiniteArray( [ -3 ], 123 ); // $ExpectError
+}
+
+// Attached to main export is a `primitives` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isFiniteArray.primitives( [ new Number( 3 ) ] ); // $ExpectType boolean
+ isFiniteArray.primitives( [ 3 ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `primitives` method is provided an unsupported number of arguments...
+{
+ isFiniteArray.primitives(); // $ExpectError
+ isFiniteArray.primitives( [ 2 ], 123 ); // $ExpectError
+}
+
+// Attached to main export is an `objects` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isFiniteArray.objects( [ new Number( -2 ) ] ); // $ExpectType boolean
+ isFiniteArray.objects( [ -2 ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `objects` method is provided an unsupported number of arguments...
+{
+ isFiniteArray.objects(); // $ExpectError
+ isFiniteArray.objects( [ 2 ], 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-finite-array/package.json b/lib/node_modules/@stdlib/assert/is-finite-array/package.json
index 890d8a29f662..bf526331b331 100644
--- a/lib/node_modules/@stdlib/assert/is-finite-array/package.json
+++ b/lib/node_modules/@stdlib/assert/is-finite-array/package.json
@@ -21,6 +21,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/index.d.ts
new file mode 100644
index 000000000000..e8cf53b38a1c
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/index.d.ts
@@ -0,0 +1,42 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Tests if a value is a numeric array.
+*
+* @param v - value to test
+* @returns boolean indicating if a value is a numeric array
+*
+* @example
+* var bool = isNumericArray( new Int8Array( 10 ) );
+* // returns true
+*
+* bool = isNumericArray( [ 1, 2, 3 ] );
+* // returns true
+*
+* bool = isNumericArray( [ '1', '2', '3' ] );
+* // returns false
+*/
+declare function isNumericArray( v: any ): boolean;
+
+
+// EXPORTS //
+
+export = isNumericArray;
diff --git a/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/test.ts
new file mode 100644
index 000000000000..0d5a3d86be58
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-numeric-array/docs/types/test.ts
@@ -0,0 +1,34 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isNumericArray = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isNumericArray( [ 1, 2, 3 ] ); // $ExpectType boolean
+ isNumericArray( [] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isNumericArray(); // $ExpectError
+ isNumericArray( [ 1, 2, 3 ], 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-numeric-array/package.json b/lib/node_modules/@stdlib/assert/is-numeric-array/package.json
index 695bb7e93a45..635c09f4c1df 100644
--- a/lib/node_modules/@stdlib/assert/is-numeric-array/package.json
+++ b/lib/node_modules/@stdlib/assert/is-numeric-array/package.json
@@ -21,6 +21,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/index.d.ts
new file mode 100644
index 000000000000..31540b5e2de6
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/index.d.ts
@@ -0,0 +1,131 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Interface defining `isRelativePath` with methods for testing POSIX and Windows paths, respectively.
+*/
+interface IsRelativePath {
+ /**
+ * Tests if a value is a relative path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a relative path
+ *
+ * @example
+ * var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+ * var bool;
+ * if ( IS_WINDOWS ) {
+ * bool = isRelativePath( 'foo\\bar\\baz' );
+ * // returns true
+ *
+ * bool = isRelativePath( 'C:\\foo\\..\\bar\\baz' );
+ * // returns false
+ * } else {
+ * bool = isRelativePath( './foo/bar/baz' );
+ * // returns true
+ *
+ * bool = isRelativePath( '/foo/../bar/baz' );
+ * // returns false
+ * }
+ */
+ ( value: any ): boolean;
+
+ /**
+ * Tests if a value is a POSIX relative path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a POSIX relative path
+ *
+ * @example
+ * var bool = isRelativePath.posix( './foo/bar/baz' );
+ * // returns true
+ *
+ * @example
+ * var bool = isRelativePath.posix( '/foo/../bar/baz' );
+ * // returns false
+ */
+ posix( value: any ): boolean;
+
+ /**
+ * Tests if a value is a Windows relative path.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a Windows relative path
+ *
+ * @example
+ * var bool = isRelativePath.win32( 'foo\\bar\\baz' );
+ * // returns true
+ *
+ * @example
+ * var bool = isRelativePath.win32( 'C:\\foo\\..\\bar\\baz' );
+ * // returns false
+ */
+ win32( value: any ): boolean;
+}
+
+/**
+* Tests if a value is a relative path.
+*
+* ## Notes
+*
+* - Function behavior is platform-specific. On Windows platforms, the function is equal to `.win32()`. On POSIX platforms, the function is equal to `.posix()`.
+*
+* @param value - value to test
+* @returns boolean indicating whether value is a relative path
+*
+* @example
+* var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+* var bool;
+* if ( IS_WINDOWS ) {
+* bool = isRelativePath( 'foo\\bar\\baz' );
+* // returns true
+*
+* bool = isRelativePath( 'C:\\foo\\..\\bar\\baz' );
+* // returns false
+* } else {
+* bool = isRelativePath( './foo/bar/baz' );
+* // returns true
+*
+* bool = isRelativePath( '/foo/../bar/baz' );
+* // returns false
+* }
+*
+* @example
+* var bool = isRelativePath.posix( './foo/bar/baz' );
+* // returns true
+*
+* @example
+* var bool = isRelativePath.posix( '/foo/../bar/baz' );
+* // returns false
+*
+* @example
+* var bool = isRelativePath.win32( 'foo\\bar\\baz' );
+* // returns true
+*
+* @example
+* var bool = isRelativePath.win32( 'C:\\foo\\..\\bar\\baz' );
+* // returns false
+*/
+declare var isRelativePath: IsRelativePath;
+
+
+// EXPORTS //
+
+export = isRelativePath;
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/test.ts
new file mode 100644
index 000000000000..ffc440205711
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/docs/types/test.ts
@@ -0,0 +1,60 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isRelativePath = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isRelativePath( 'foo\\bar\\baz' ); // $ExpectType boolean
+ isRelativePath( './foo/bar/baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isRelativePath(); // $ExpectError
+ isRelativePath( 'foo\\bar\\baz', 123 ); // $ExpectError
+}
+
+// Attached to main export is a `posix` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isRelativePath.posix( './foo/bar/baz' ); // $ExpectType boolean
+ isRelativePath.posix( '/foo/../bar/baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `posix` method is provided an unsupported number of arguments...
+{
+ isRelativePath.posix(); // $ExpectError
+ isRelativePath.posix( '/foo/../bar/baz', 123 ); // $ExpectError
+}
+
+// Attached to main export is a `win32` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isRelativePath.win32( 'foo\\bar\\baz' ); // $ExpectType boolean
+ isRelativePath.win32( 'C:\\foo\\..\\bar\\baz' ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `win32` method is provided an unsupported number of arguments...
+{
+ isRelativePath.win32(); // $ExpectError
+ isRelativePath.win32( 'C:\\foo\\..\\bar\\baz', 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-relative-path/package.json b/lib/node_modules/@stdlib/assert/is-relative-path/package.json
index 531599603f85..6ab176861b51 100644
--- a/lib/node_modules/@stdlib/assert/is-relative-path/package.json
+++ b/lib/node_modules/@stdlib/assert/is-relative-path/package.json
@@ -22,6 +22,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/index.d.ts
new file mode 100644
index 000000000000..081d0c36b27d
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/index.d.ts
@@ -0,0 +1,129 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Interface defining `isSafeIntegerArray` with methods for testing for primitive and object arrays, respectively.
+*/
+interface IsSafeIntegerArray {
+ /**
+ * Tests if a value is an array-like object containing only safe integers.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is an array-like object containing only safe integers
+ *
+ * @example
+ * var bool = isSafeIntegerArray( [ -3.0, new Number(0.0), 2.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeIntegerArray( [ -3.0, '3.0' ] );
+ * // returns false
+ */
+ ( value: any ): boolean;
+
+ /**
+ * Tests if a value is an array-like object containing only primitive safe integer values.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is an array-like object containing only primitive safe integer values
+ *
+ * @example
+ * var bool = isSafeIntegerArray.primitives( [ -1.0, 10.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeIntegerArray.primitives( [ -1.0, 0.0, 5.0 ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeIntegerArray.primitives( [ -3.0, new Number(-1.0) ] );
+ * // returns false
+ */
+ primitives( value: any ): boolean;
+
+ /**
+ * Tests if a value is an array-like object containing only number objects having safe integer values.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is an array-like object containing only number objects having safe integer values
+ *
+ * @example
+ * var bool = isSafeIntegerArray.objects( [ new Number(1.0), new Number(3.0) ] );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeIntegerArray.objects( [ -1.0, 0.0, 3.0 ] );
+ * // returns false
+ *
+ * @example
+ * var bool = isSafeIntegerArray.objects( [ 3.0, new Number(-1.0) ] );
+ * // returns false
+ */
+ objects( value: any ): boolean;
+}
+
+/**
+* Tests if a value is an array-like object containing only safe integers.
+*
+* ## Notes
+*
+* - An integer valued number is "safe" when the number can be exactly represented as a double-precision floating-point number.
+*
+* @param value - value to test
+* @returns boolean indicating whether value is an array-like object containing only safe integers
+*
+* @example
+* var bool = isSafeIntegerArray( [ -3.0, new Number(0.0), 2.0 ] );
+* // returns true
+*
+* @example
+* var bool = isSafeIntegerArray( [ -3.0, '3.0' ] );
+* // returns false
+*
+* @example
+* var bool = isSafeIntegerArray.primitives( [ -1.0, 10.0 ] );
+* // returns true
+*
+* @example
+* var bool = isSafeIntegerArray.primitives( [ -1.0, 0.0, 5.0 ] );
+* // returns true
+*
+* @example
+* var bool = isSafeIntegerArray.primitives( [ -3.0, new Number(-1.0) ] );
+* // returns false
+*
+* @example
+* var bool = isSafeIntegerArray.objects( [ new Number(1.0), new Number(3.0) ] );
+* // returns true
+*
+* @example
+* var bool = isSafeIntegerArray.objects( [ -1.0, 0.0, 3.0 ] );
+* // returns false
+*
+* @example
+* var bool = isSafeIntegerArray.objects( [ 3.0, new Number(-1.0) ] );
+* // returns false
+*/
+declare var isSafeIntegerArray: IsSafeIntegerArray;
+
+
+// EXPORTS //
+
+export = isSafeIntegerArray;
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/test.ts
new file mode 100644
index 000000000000..30437361300c
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer-array/docs/types/test.ts
@@ -0,0 +1,60 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isSafeIntegerArray = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isSafeIntegerArray( [ 4 ] ); // $ExpectType boolean
+ isSafeIntegerArray( [ 2.8 ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isSafeIntegerArray(); // $ExpectError
+ isSafeIntegerArray( [ -3 ], 123 ); // $ExpectError
+}
+
+// Attached to main export is a `primitives` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isSafeIntegerArray.primitives( [ new Number( 3 ) ] ); // $ExpectType boolean
+ isSafeIntegerArray.primitives( [ 3 ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `primitives` method is provided an unsupported number of arguments...
+{
+ isSafeIntegerArray.primitives(); // $ExpectError
+ isSafeIntegerArray.primitives( [ 2 ], 123 ); // $ExpectError
+}
+
+// Attached to main export is an `objects` method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isSafeIntegerArray.objects( [ new Number( -2 ) ] ); // $ExpectType boolean
+ isSafeIntegerArray.objects( [ -2 ] ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the `objects` method is provided an unsupported number of arguments...
+{
+ isSafeIntegerArray.objects(); // $ExpectError
+ isSafeIntegerArray.objects( [ 2 ], 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer-array/package.json b/lib/node_modules/@stdlib/assert/is-safe-integer-array/package.json
index 2de8e8e33534..bcde2dfc2346 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer-array/package.json
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer-array/package.json
@@ -21,6 +21,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/index.d.ts b/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/index.d.ts
new file mode 100644
index 000000000000..db95a75ce074
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/index.d.ts
@@ -0,0 +1,130 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Interface defining `isSafeInteger` with methods for testing for primitives and objects, respectively.
+*/
+interface IsSafeInteger {
+ /**
+ * Tests if a value is a safe integer.
+ *
+ * @param value - value to test
+ * @returns boolean indicating whether value is a safe integer
+ *
+ * @example
+ * var bool = isSafeInteger( 5.0 );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeInteger( new Number( 5.0 ) );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeInteger( 2.0e300 );
+ * // returns false
+ *
+ * @example
+ * var bool = isSafeInteger( -3.14 );
+ * // returns false
+ *
+ * @example
+ * var bool = isSafeInteger( null );
+ * // returns false
+ */
+ ( value: any ): boolean;
+
+ /**
+ * Tests if a value is a number primitive having a safe integer value.
+ *
+ * @param value - value to test
+ * @returns boolean indicating if a value is a number primitive having a safe integer value
+ *
+ * @example
+ * var bool = isSafeInteger.isPrimitive( -3.0 );
+ * // returns true
+ *
+ * @example
+ * var bool = isSafeInteger.isPrimitive( new Number( -3.0 ) );
+ * // returns false
+ */
+ isPrimitive( value: any ): boolean;
+
+
+ /**
+ * Tests if a value is a number object having a safe integer value.
+ *
+ * @param value - value to test
+ * @returns boolean indicating if a value is a number object having a safe integer value
+ *
+ * @example
+ * var bool = isSafeInteger.isObject( 3.0 );
+ * // returns false
+ *
+ * @example
+ * var bool = isSafeInteger.isObject( new Number( 3.0 ) );
+ * // returns true
+ */
+ isObject( value: any ): boolean;
+}
+
+/**
+* Tests if a value is a safe integer.
+*
+* ## Notes
+*
+* - An integer valued number is "safe" when the number can be exactly represented as a double-precision floating-point number.
+*
+* @param value - value to test
+* @returns boolean indicating whether value is a safe integer
+*
+* @example
+* var bool = isSafeInteger( 5.0 );
+* // returns true
+*
+* @example
+* var bool = isSafeInteger( new Number( 5.0 ) );
+* // returns true
+*
+* @example
+* var bool = isSafeInteger( 2.0e300 );
+* // returns false
+*
+* @example
+* var bool = isSafeInteger( -3.14 );
+* // returns false
+*
+* @example
+* var bool = isSafeInteger( null );
+* // returns false
+*
+* @example
+* var bool = isSafeInteger.isPrimitive( -3.0 );
+* // returns true
+*
+* @example
+* var bool = isSafeInteger.isObject( new Number( 3.0 ) );
+* // returns true
+*/
+declare var isSafeInteger: IsSafeInteger;
+
+
+// EXPORTS //
+
+export = isSafeInteger;
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/test.ts
new file mode 100644
index 000000000000..85c10b3dc682
--- /dev/null
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/docs/types/test.ts
@@ -0,0 +1,61 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isSafeInteger = require( './index' );
+
+
+// TESTS //
+
+// The function returns a boolean...
+{
+ isSafeInteger( 1.2 ); // $ExpectType boolean
+ isSafeInteger( 2 ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ isSafeInteger(); // $ExpectError
+ isSafeInteger( 2, 123 ); // $ExpectError
+}
+
+// Attached to main export is an isPrimitive method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isSafeInteger.isPrimitive( new Number( 2 ) ); // $ExpectType boolean
+ isSafeInteger.isPrimitive( 2 ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the isPrimitive method is provided an unsupported number of arguments...
+{
+ isSafeInteger.isPrimitive(); // $ExpectError
+ isSafeInteger.isPrimitive( 2, 123 ); // $ExpectError
+}
+
+
+// Attached to main export is an isPrimitive method which returns a boolean...
+{
+ // tslint:disable-next-line:no-construct
+ isSafeInteger.isObject( new Number( 2 ) ); // $ExpectType boolean
+ isSafeInteger.isObject( 2 ); // $ExpectType boolean
+}
+
+// The compiler throws an error if the isObject method is provided an unsupported number of arguments...
+{
+ isSafeInteger.isObject(); // $ExpectError
+ isSafeInteger.isObject( 2, 123 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/assert/is-safe-integer/package.json b/lib/node_modules/@stdlib/assert/is-safe-integer/package.json
index 263951f3d14b..4b6c1359db3e 100644
--- a/lib/node_modules/@stdlib/assert/is-safe-integer/package.json
+++ b/lib/node_modules/@stdlib/assert/is-safe-integer/package.json
@@ -21,6 +21,7 @@
"lib": "./lib",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/assert/is-string-array/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-string-array/docs/types/test.ts
index b0b7bbfd5831..a95746f17c6c 100644
--- a/lib/node_modules/@stdlib/assert/is-string-array/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/assert/is-string-array/docs/types/test.ts
@@ -54,7 +54,7 @@ import isStringArray = require( './index' );
isStringArray.objects( [ 'abc' ] ); // $ExpectType boolean
}
-// The compiler throws an error if the `objects method is provided an unsupported number of arguments...
+// The compiler throws an error if the `objects` method is provided an unsupported number of arguments...
{
isStringArray.objects(); // $ExpectError
isStringArray.objects( [ 'abc' ], 123 ); // $ExpectError
diff --git a/lib/node_modules/@stdlib/assert/is-string/docs/types/test.ts b/lib/node_modules/@stdlib/assert/is-string/docs/types/test.ts
index 6678046921be..47c434c52374 100644
--- a/lib/node_modules/@stdlib/assert/is-string/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/assert/is-string/docs/types/test.ts
@@ -33,28 +33,28 @@ import isString = require( './index' );
isString( 'abc', 123 ); // $ExpectError
}
-// Attached to main export is an isPrimitive method which returns a boolean...
+// Attached to main export is an `isPrimitive` method which returns a boolean...
{
// tslint:disable-next-line:no-construct
isString.isPrimitive( new String( 'abc' ) ); // $ExpectType boolean
isString.isPrimitive( 'abc' ); // $ExpectType boolean
}
-// The compiler throws an error if the isPrimitive method is provided an unsupported number of arguments...
+// The compiler throws an error if the `isPrimitive` method is provided an unsupported number of arguments...
{
isString.isPrimitive(); // $ExpectError
isString.isPrimitive( 'abc', 123 ); // $ExpectError
}
-// Attached to main export is an isPrimitive method which returns a boolean...
+// Attached to main export is an `isObject` method which returns a boolean...
{
// tslint:disable-next-line:no-construct
isString.isObject( new String( 'abc' ) ); // $ExpectType boolean
isString.isObject( 'abc' ); // $ExpectType boolean
}
-// The compiler throws an error if the isObject method is provided an unsupported number of arguments...
+// The compiler throws an error if the `isObject` method is provided an unsupported number of arguments...
{
isString.isObject(); // $ExpectError
isString.isObject( 'abc', 123 ); // $ExpectError
diff --git a/lib/node_modules/@stdlib/datasets/month-names-en/README.md b/lib/node_modules/@stdlib/datasets/month-names-en/README.md
index 364f19e68e10..18cd8d57ffd3 100644
--- a/lib/node_modules/@stdlib/datasets/month-names-en/README.md
+++ b/lib/node_modules/@stdlib/datasets/month-names-en/README.md
@@ -67,8 +67,7 @@ var list = months();
```javascript
-var floor = require( '@stdlib/math/base/special/floor' );
-var randu = require( '@stdlib/random/base/randu' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
var months = require( '@stdlib/datasets/month-names-en' );
var list;
@@ -81,7 +80,7 @@ len = list.length;
// Select random months from the list...
for ( i = 0; i < 100; i++ ) {
- idx = floor( randu()*len );
+ idx = discreteUniform( 0, len-1 );
console.log( list[ idx ] );
}
```
diff --git a/lib/node_modules/@stdlib/datasets/month-names-en/examples/index.js b/lib/node_modules/@stdlib/datasets/month-names-en/examples/index.js
index 0c8bb753f3e5..a8e29633cb04 100644
--- a/lib/node_modules/@stdlib/datasets/month-names-en/examples/index.js
+++ b/lib/node_modules/@stdlib/datasets/month-names-en/examples/index.js
@@ -18,8 +18,7 @@
'use strict';
-var floor = require( '@stdlib/math/base/special/floor' );
-var randu = require( '@stdlib/random/base/randu' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
var months = require( './../lib' );
var list;
@@ -32,6 +31,6 @@ len = list.length;
// Select random months from the list...
for ( i = 0; i < 100; i++ ) {
- idx = floor( randu()*len );
+ idx = discreteUniform( 0, len-1 );
console.log( list[ idx ] );
}
diff --git a/lib/node_modules/@stdlib/iter/dedupe-by/README.md b/lib/node_modules/@stdlib/iter/dedupe-by/README.md
index 3637c3bfdd3d..eacc9a0e7883 100644
--- a/lib/node_modules/@stdlib/iter/dedupe-by/README.md
+++ b/lib/node_modules/@stdlib/iter/dedupe-by/README.md
@@ -76,7 +76,7 @@ The returned [iterator][mdn-iterator-protocol] protocol-compliant object has the
- **next**: function which returns an [iterator][mdn-iterator-protocol] protocol-compliant object containing the next iterated value (if one exists) assigned to a `value` property and a `done` property having a `boolean` value indicating whether the [iterator][mdn-iterator-protocol] is finished.
- **return**: function which closes an [iterator][mdn-iterator-protocol] and returns a single (optional) argument in an [iterator][mdn-iterator-protocol] protocol-compliant object.
-The provided function is provided five arguments:
+The callback function is provided five arguments:
- **curr**: current source iterated value.
- **sprev**: previous source iterated value.
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/README.md b/lib/node_modules/@stdlib/math/base/special/cosc/README.md
new file mode 100644
index 000000000000..55e93fe90878
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/README.md
@@ -0,0 +1,106 @@
+
+
+# cosc
+
+> Compute the derivative of the [cardinal sine][sinc] of a number.
+
+
+
+The derivative of the normalized [cardinal sine][sinc] is defined as
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+for any real number `x`.
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var cosc = require('@stdlib/math/base/special/cosc');
+```
+
+#### cosc( x )
+
+Computes the derivative of the normalized [cardinal sine][sinc] of a `number`.
+
+```javascript
+var v = cosc(0.5);
+// returns ~-1.273
+
+v = cosc(-1.2);
+// returns ~0.544
+
+v = cosc(0.0);
+// returns 0.0
+
+v = cosc(NaN);
+// returns NaN
+```
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var linspace = require('@stdlib/math/utils/linspace');
+var cosc = require('@stdlib/math/base/special/cosc');
+
+var x = linspace(-5.0, 5.0, 100);
+var i;
+
+for (i = 0; i < x.length; i++) {
+ console.log(cosc(x[i]));
+}
+```
+
+
+
+
+
+
+
+[sinc]: https://en.wikipedia.org/wiki/Sinc_function
+
+
+
+
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/benchmark/benchmark.js b/lib/node_modules/@stdlib/math/base/special/cosc/benchmark/benchmark.js
new file mode 100644
index 000000000000..4f78c522951a
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/benchmark/benchmark.js
@@ -0,0 +1,51 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2018 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 randu = require( '@stdlib/random/base/randu' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pkg = require( './../package.json' ).name;
+var cosc = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var x;
+ var y;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ x = ( randu() * 2.0 ) - 2.0;
+ y = cosc( x );
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( y ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/docs/img/equation_cosc_function.svg b/lib/node_modules/@stdlib/math/base/special/cosc/docs/img/equation_cosc_function.svg
new file mode 100644
index 000000000000..8da3aa674beb
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/docs/img/equation_cosc_function.svg
@@ -0,0 +1,73 @@
+
+
+
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/index.d.ts
new file mode 100644
index 000000000000..3e42dec1e01b
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/index.d.ts
@@ -0,0 +1,48 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Computes the derivative of the normalized cardinal sine of a number.
+*
+* @param x - input value
+* @returns derivative of cardinal sine
+*
+* @example
+* var v = cosc( 0.5 );
+* // returns ~-1.273
+*
+* @example
+* var v = cosc( -1.2 );
+* // returns ~0.544
+*
+* @example
+* var v = cosc( 0.0 );
+* // returns 0.0
+*
+* @example
+* var v = cosc( NaN );
+* // returns NaN
+*/
+declare function cosc( x: number ): number;
+
+
+// EXPORTS //
+
+export = cosc;
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/test.ts b/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/test.ts
new file mode 100644
index 000000000000..977afeb44a82
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 cosc = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+ cosc( 8 ); // $ExpectType number
+}
+
+// The function does not compile if provided a value other than a number...
+{
+ cosc( true ); // $ExpectError
+ cosc( false ); // $ExpectError
+ cosc( null ); // $ExpectError
+ cosc( undefined ); // $ExpectError
+ cosc( '5' ); // $ExpectError
+ cosc( [] ); // $ExpectError
+ cosc( {} ); // $ExpectError
+ cosc( ( x: number ): number => x ); // $ExpectError
+}
+
+// The function does not compile if provided insufficient arguments...
+{
+ cosc(); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/examples/index.js b/lib/node_modules/@stdlib/math/base/special/cosc/examples/index.js
new file mode 100644
index 000000000000..4dbe8361d1b0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/examples/index.js
@@ -0,0 +1,29 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2018 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 linspace = require( '@stdlib/math/utils/linspace' );
+var cosc = require( './../lib' );
+
+var x = linspace( -5.0, 5.0, 100 );
+var i;
+
+for ( i = 0; i < x.length; i++ ) {
+ console.log( 'cosc( %d ) = %d', x[ i ], cosc( x[ i ] ) );
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/lib/cosc.js b/lib/node_modules/@stdlib/math/base/special/cosc/lib/cosc.js
new file mode 100644
index 000000000000..aef853bc3d68
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/lib/cosc.js
@@ -0,0 +1,89 @@
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2019 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 sinpi = require('@stdlib/math/base/special/sinpi');
+var cospi = require('@stdlib/math/base/special/cospi');
+var isnan = require('@stdlib/math/base/assert/is-nan');
+var isInfinite = require('@stdlib/math/base/assert/is-infinite');
+var PI = require('@stdlib/constants/math/float64-pi');
+
+
+// MAIN //
+
+/**
+ * Computes the derivative of the normalized cardinal sine of a number.
+ *
+ * ## Method
+ *
+ * For \\( x \neq 0 \\), the derivative of \operatorname{sinc}(x) is calculated as
+ *
+ * ```tex
+ * \operatorname{cosc}(x) = \frac{\operatorname{cos}(\pi x)}{x} - \frac{\operatorname{sin}(\pi x)}{\pi x^2}
+ * ```
+ *
+ * ## Special Cases
+ *
+ * ```tex
+ * \begin{align*}
+ * \operatorname{cosc}(0) &= 0 & \\
+ * \operatorname{cosc}(\infty) &= 0 & \\
+ * \operatorname{cosc}(-\infty) &= 0 & \\
+ * \operatorname{cosc}(\mathrm{NaN}) &= \mathrm{NaN}
+ * \end{align*}
+ * ```
+ *
+ * @param {number} x - input value
+ * @returns {number} derivative of normalized sinc(x)
+ *
+ * @example
+ * var v = cosc( 0.5 )
+ * // returns ~-1.273
+ *
+ * @example
+ * var v = cosc( -1.2 )
+ * // returns ~0.544
+ *
+ * @example
+ * var v = cosc( 0.0 )
+ * // returns 0.0
+ *
+ * @example
+ * var v = cosc( NaN )
+ * // returns NaN
+ */
+function cosc(x) {
+ if (isnan(x)) {
+ return NaN;
+ }
+ if (isInfinite(x)) {
+ return 0.0;
+ }
+ if (x === 0.0) {
+ return 0.0;
+ }
+ return ( cospi(x) - ( sinpi(x) / ( PI * x ))) / x;
+}
+
+
+// EXPORTS //
+
+module.exports = cosc;
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/lib/index.js b/lib/node_modules/@stdlib/math/base/special/cosc/lib/index.js
new file mode 100644
index 000000000000..d241c35141b9
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/lib/index.js
@@ -0,0 +1,49 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2018 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';
+
+/**
+* Compute the derivative of the normalized cardinal sine of a number.
+*
+* @module @stdlib/math/base/special/cosc
+*
+* @example
+* var cosc = require( '@stdlib/math/base/special/cosc' );
+*
+* var v = cosc( 0.5 );
+* // returns ~-1.273
+*
+* v = cosc( -1.2 );
+* // returns ~-0.544
+*
+* v = cosc( 0.0 );
+* // returns 0.0
+*
+* v = cosc( NaN );
+* // returns NaN
+*/
+
+// MODULES //
+
+var cosc = require( './cosc.js' );
+
+
+// EXPORTS //
+
+module.exports = cosc;
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/package.json b/lib/node_modules/@stdlib/math/base/special/cosc/package.json
new file mode 100644
index 000000000000..8cbfe2f8b032
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/package.json
@@ -0,0 +1,65 @@
+{
+ "name": "@stdlib/math/base/special/cosc",
+ "version": "0.0.0",
+ "description": "Compute the derivative of the normalized cardinal sine of a number.",
+ "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",
+ "stdmath",
+ "mathematics",
+ "math",
+ "sin",
+ "sinc",
+ "sine",
+ "cardinal",
+ "trig",
+ "trigonometry",
+ "normalized",
+ "cosc"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/data.json b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/data.json
new file mode 100644
index 000000000000..4fa25300efd1
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/data.json
@@ -0,0 +1 @@
+{"expected":[-0.01,-0.00812149427429548,-0.003121108309002221,0.0030962683142824222,0.008151412893289012,0.01010116442222158,0.00818528849819461,0.0031227782363181535,-0.00315784475741559,-0.008253112289619722,-0.010204296726690465,-0.008250312557189577,-0.0031244583581772783,0.0032206494924090856,0.008356821657233877,0.010309457904912616,0.008316604967128521,0.003126149512410935,-0.0032847203026405984,-0.008462603486725355,-0.010416711496108446,-0.008384205861783236,-0.003127852581317167,0.003350096550261669,0.008570522895066615,0.010526123721589854,0.008453157078657408,0.003129568494495093,-0.003416819259505879,-0.008680647765013344,-0.010637763627733028,-0.00852350225031451,-0.003131298231892594,0.0034849312053431263,0.0087930488934743,0.010751703238195437,0.008595286901644057,0.003133042827085871,-0.0035544770078541283,-0.008907800149544995,-0.010868017716081948,-0.00866855855352168,-0.003134803370811257,0.0036255032327911513,0.009024978642928807,0.01098678553682696,0.008743366833358714,0.003136581014771224,-0.0036980584987722216,-0.009144664903569825,-0.01110808867262818,-0.00881976359308156,-0.003138376975742579,0.0037721935916563555,0.009266943073358881,0.011232012789342325,0.008897803035129895,0.0031401925400036694,-0.0038479615866356515,-0.009391901110889398,-0.011358647456836684,-0.008977541847116934,-0.003142029068130527,0.003925417978690644,0.009519631010291936,0.011488086373881271,0.009059039345854477,0.0031438880001679456,-0.004004620822052521,-0.009650229035309477,-0.011620427608768474,-0.009142357631511437,-0.003145770861242484,0.004085630879438947,0.00978379596984657,0.011755773856957943,0.009227561752747242,0.0031476792676268534,-0.0041685117818388165,-0.009920437386380947,-0.011894232717169365,-0.009314719883744509,-0.0031496149333322386,0.004253330199759775,0.010060263933721138,0.012035916987482258,0.009403903514148389,0.003151579677246577,-0.004340156026875548,-0.010203391645776863,-0.01218094498315565,-0.00949518765303086,-0.003153575430906623,0.0044290625771676315,0.010349942273133982,0.0123294408780486,0.009588651048097785,0.003155604246932816,-0.004520126796697779,-0.010500043639444031,-0.012481535071712575,-0.009684376421486637,-0.00315766830822887,0.004613429491328998,0.010653830024801568,0.012637364584435408,0.009782450723638156,0.0031597699379892277,-0.004709055571778544,-0.010811442578545,-0.012797073482752943,-0.009882965406879052,-0.0031619116106340827,0.004807094317597618,0.010973029764128478,0.012960813338204374,0.00998601672052458,0.003164095963733304,-0.004907639661768939,-0.011138747839031213,-0.013128743722402237,-0.010091706029502013,-0.0031663258110615437,0.005010790497862551,0.011308761372944919,0.013301032741814602,0.010200140158711596,0.003168604156869466,-0.005116651011826356,-0.01148324380787106,-0.013477857616027704,-0.010311431765583433,-0.0031709342115422232,0.00522533104078549,0.011662378064114496,0.013659405303668532,0.010425699743560966,0.0031733194087608793,-0.00533694646141234,-0.011846357196644102,-0.013845873180635225,-0.010543069659548106,-0.0031757634243750866,0.005451619610788872,0.012035385106750649,0.014037469775805778,0.010663674228702737,0.003178270197142987,-0.0055694797429380145,-0.012229677314536917,-0.014234415569991356,-0.010787653830349962,-0.0031808439515949756,0.005690663524641332,0.012429461798371616,0.01443694386456738,0.010915157069230522,0.003183489223230353,-0.005815315574503863,-0.012634979908201567,-0.014645301726977929,-0.011046341386800988,-0.0031862108863668155,0.005943589049772812,0.012846487360393132,0.014859751021167761,0.011181373727871178,0.0031890141849221848,-0.006075646285877538,-0.013064255322745485,-0.015080569531979249,-0.011320431268515493,-0.0031919047665319956,0.0062116594943429386,0.013288571599333547,0.015308052193662859,0.01146370221192045,0.0031948887203763674,-0.006351811525344912,-0.013519741926087372,-0.015542512433926502,-0.011611386659702476,-0.0031979726192309485,0.00649629670204585,0.013758091389349742,0.015784283646401012,0.011763697567151385,0.003201163566244387,-0.0066453217346742165,-0.014003965981270357,-0.016033720806069535,-0.011920861792014157,-0.003204469247099955,0.006799106723426362,0.01425773430767519,0.016291202244120055,0.012083121247654685,0.0032078979882478073,-0.006957886260387113,-0.014519789466139717,-0.01655713160088305,-0.012250734172934985,-0.0032114588220571024,0.0071219106420964745,0.014790551114397884,0.016831939978056477,0.01242397653281789,0.0032151615598177952,-0.007291447205917784,-0.015070467751965915,-0.017116088314353066,-0.01260314356568165,-0.003219016873718083,0.007466781805232692,0.015360019241083843,0.01741007001210697,0.012788551495575182,0.003223036389054492,-0.00764822044055932,-0.01565971959676787,-0.017714413846320765,-0.012980539430315071,-0.0032272327881880795,0.007836091066189176,0.015970120080109635,0.01802968719223525,0.013179471469369881,0.003231619927960568,-0.008030745594753051,-0.016291812633970636,-0.018356499612863893,-0.013385739049108336,-0.00323621297262763,0.008232562125508797,0.016625433706132696,0.018695506854219463,0.013599763557169867,0.0032410285446719256,-0.008441947426004633,-0.016971668511843934,-0.019047415303325068,-0.013821999252707376,-0.003246084896317892,0.008659339701404164,0.017331255795841417,0.019412986972785002,0.014052936535059249,0.0032514021050499722,-0.008885211691110761,-0.01770499316347801,-0.01979304508592873,-0.014293105610354162,-0.003257002297055657,0.00912007413874882,0.018093743061928933,0.02018848034868344,0.014543080613712378,0.0032629099032424514,-0.0093644796890727,-0.018498439505864002,-0.020600258008740227,-0.014803484254502976,-0.0032691519533817525,0.009619027274371875,0.01892009565799568,0.021029425819783135,0.015074993063731617,0.0032757584149872795,-0.00988436706362933,-0.019359812394000715,-0.021477123049106057,-0.01535834333664347,-0.003282762584911327,0.010161206060496421,0.019818788004259534,0.021944590691662356,0.015654337880393054,0.003290201543197523,-0.010450314451523168,-0.020298329212416245,-0.02243318308335344,-0.015963853696976654,-0.003298116680810401,0.010752532824619953,0.020799863724121747,0.022944381142422733,0.01628785075620152,0.003306554315280754,-0.011068780400162948,-0.021324954559734408,-0.02347980751160371,-0.016627382043497237,-0.003315566411424332,0.01140006444442462,0.02187531647405393,0.024041243927155263,0.016983605104012988,0.003325211428137928,-0.011747491068296874,-0.02245283482643723,-0.0246306512064508,-0.01735779534957546,-0.0033355553171232973,0.012112277655090231,0.023059587338818334,0.025250192326570428,0.017751361450711965,0.0033466727055086465,-0.01249576721147865,-0.023697869270739812,-0.025902259166312447,-0.01816586320510359,-0.0033586483021096486,0.012899444997921911,0.024370222654297162,0.026589503608509014,0.0186030323600268,0.0033715785770017117,-0.01332495787239082,-0.025079470373926452,-0.027314873855236274,-0.01906479697462282,-0.003385573776840249,0.013774136878199323,0.025828756054358606,0.028081657004541193,0.019553310044403843,0.0034007603548818844,-0.014249023728810697,-0.026621590945328205,-0.02889352918548005,-0.020070983283998794,-0.003417283916182898,0.014751901997059412,0.027461909278015884,0.02975461486459067,0.0206205271859705,0.0034353128066700544,-0.015285334013198891,-0.02835413393454925,-0.030669557342723454,-0.02120499875924687,-0.0034550425121591464,0.015852204728958347,0.029303254743966438,0.03164360298558541,0.021827858721148303,0.0034767010831060863,-0.016455774131318216,-0.030314922330699712,-0.0326827024141269,-0.022493040401276088,-0.0035005558678768887,0.017099740214987922,0.031395561243160695,0.033793632777084276,0.02320503325363453,0.003526921928034601,-0.01778831508054343,-0.03255250714719134,-0.03498414641426959,-0.023968984721854433,-0.003556172633623004,0.018526317463920545,0.03379417427612865,0.03626315280389512,0.024790825340908974,0.003588753108513572,-0.019319285989475757,-0.03513026121930935,-0.037640942824677275,-0.02567742350211673,-0.0036251974369456187,0.020173618769514737,0.036572005695844394,0.039129467276645596,0.026636778422656198,0.0036661508835267517,-0.021096746786180974,-0.03813250247905093,-0.04074268561934531,-0.02767826279134453,-0.003712398868452382,0.022097350989817487,0.039827103520068546,0.04249700648565127,0.02881293067438625,0.0037649051510872692,-0.023185636531019935,-0.041673926181255316,-0.04441184944061053,-0.030053912112161706,-0.0038248627248875,0.024373682462851164,0.04369450526410966,0.046510368788935726,0.0314169242744013,0.0038937625001402303,-0.025675892293995015,-0.04591463864369962,-0.04882039672067211,-0.03292094140530629,-0.003973487251273077,0.027109581013637682,0.04836549706811723,0.051375687462213646,0.0345890842244068,0.004066442035947817,-0.028695749339446207,-0.05108509968251522,-0.05421758080245042,-0.03644981745380321,-0.004175738212901589,0.03046011869912175,0.05412030405157122,0.05739725972685708,0.03853858757404314,0.004305457794519284,-0.03243453536557216,-0.05752953288409424,-0.06097886535751968,-0.04090010182169904,-0.004461040865697827,0.034658906877642205,0.06138657654492091,0.06504387465168626,0.04359156158745559,0.004649866181189457,-0.03718392169212095,-0.06578600135001975,-0.06969738132588381,-0.046687351130701694,-0.004882143412842506,0.04007494774011246,0.07085101461865803,0.07507732069893194,0.05028600707885468,0.0051723239917836885,-0.04341775126709084,-0.076745195017236,-0.08136838455587699,-0.05452087591442174,-0.0055414059678527295,0.047327108644376954,0.08369050188828549,0.08882366520406383,0.0595769536196441,0.006020844208266374,-0.051960170196212484,-0.09199586830884758,-0.09779954801621371,-0.06571853281240682,-0.006659483591272928,0.05753793227387973,0.102104421126759,0.108814387121977,0.07333670400837225,0.0075365140735629355,-0.06438117053519031,-0.11467520634228848,-0.12265229755114014,-0.0830355687253477,-0.00878726106714186,0.07297354481615657,0.13073290777843743,0.14055847603907592,0.09579964829461451,0.010658704556850975,-0.08407902444436054,-0.15196215441325056,-0.16463641240544877,-0.11334796197050227,-0.013641471368829275,0.09897630452643902,0.181340478925086,0.1987410128934797,0.1389716668160917,0.018827501459412106,-0.11996867347464639,-0.22467198754347398,-0.25077922645365325,-0.17984592056550092,-0.02907249597049959,0.15161088566088235,0.2949792428601262,0.339924233413759,0.2550497554121839,0.0539677630579552,-0.2039180987220051,-0.4287385791042895,-0.5277097871904384,-0.4365287365315006,-0.14432827008569518,0.29662159607454786,0.7807636508236593,1.1767764071555131,1.3650495572258399,1.2738343594482993,0.9027661773368884,0.32607088084000435,-0.3260708808400289,-0.9027661773368884,-1.2738343594482993,-1.3650495572258399,-1.1767764071555238,-0.7807636508236429,-0.29662159607454786,0.14432827008569518,0.4365287365315006,0.5277097871904387,0.42873857910428326,0.2039180987220051,-0.0539677630579552,-0.2550497554121839,-0.3399242334137584,-0.29497924286012256,-0.15161088566088235,0.02907249597049959,0.17984592056548854,0.25077922645365247,0.22467198754347142,0.11996867347464639,-0.018827501459412106,-0.13897166681608156,-0.19874101289347895,-0.1813404789250841,-0.09897630452643902,0.013641471368829275,0.11334796197049377,0.16463641240544807,0.15196215441324898,0.08407902444436054,-0.010658704556850975,-0.09579964829460716,-0.14055847603907656,-0.13073290777843613,-0.07297354481615657,0.00878726106714186,0.08303556872534126,0.12265229755114072,0.11467520634228734,0.06438117053519031,-0.0075365140735629355,-0.07333670400836652,-0.10881438712197751,-0.10210442112675801,-0.05753793227387973,0.006659483591272928,0.06571853281240164,0.09779954801621418,0.09199586830884758,0.051960170196212484,-0.006020844208266374,-0.059576953619639404,-0.08882366520406428,-0.08369050188828549,-0.047327108644376954,0.0055414059678527295,0.05452087591441745,0.0813683845558774,0.076745195017236,0.04341775126709084,-0.0051723239917836885,-0.050286007078850704,-0.07507732069893232,-0.07085101461865803,-0.04007494774011246,0.004882143412842506,0.04668735113069801,0.06969738132588417,0.06578600135001975,0.03718392169212095,-0.004649866181189457,-0.04359156158745217,-0.0650438746516866,-0.06138657654492091,-0.034658906877642205,0.004461040865697827,0.04090010182169583,0.06097886535752,0.05752953288409424,0.03243453536557216,-0.00430545779451794,-0.03853858757404012,-0.05739725972685738,-0.05412030405157122,-0.03046011869912175,0.004175738212901589,0.03644981745380037,0.05421758080245069,0.05108509968251522,0.028695749339446207,-0.004066442035946617,-0.03458908422440411,-0.0513756874622139,-0.04836549706811723,-0.027109581013637682,0.003973487251273077,0.03292094140530714,0.04882039672067235,0.04591463864369962,0.025675892293995015,-0.003893762500139148,-0.03141692427440211,-0.046510368788935955,-0.04369450526410966,-0.024373682462851164,0.0038248627248875,0.030053912112162476,0.04441184944061053,0.041673926181255316,0.023185636531019935,-0.0037649051510862826,-0.02881293067438698,-0.04249700648565127,-0.039827103520068546,-0.022097350989817487,0.003712398868452382,0.027678262791345228,0.04074268561934531,0.03813250247905093,0.021096746786180974,-0.003666150883525846,-0.026636778422656875,-0.039129467276645596,-0.036572005695844394,-0.020173618769514737,0.0036251974369456187,0.02567742350211738,0.037640942824677275,0.03513026121930935,0.019319285989475757,-0.0035887531085127353,-0.02479082534090959,-0.03626315280389512,-0.03379417427612865,-0.018526317463920545,0.003556172633623004,0.02396898472185503,0.03498414641426959,0.03255250714719134,0.017788315080545486,-0.003526921928033824,-0.023205033253635106,-0.033793632777084276,-0.031395561243160695,-0.017099740214989913,0.0035005558678768887,0.02249304040127664,0.0326827024141269,0.030314922330699712,0.016455774131320138,-0.0034767010831053603,-0.021827858721148834,-0.03164360298558541,-0.029303254743966438,-0.01585220472896021,0.003455042512161255,0.021204998759247386,0.030669557342723454,0.02835413393454925,0.0152853340132007,-0.003435312806672097,-0.020620527185971,-0.02975461486459067,-0.027461909278015884,-0.01475190199706117,0.00341728391618488,0.020070983283999273,0.02889352918548005,0.026621590945328205,0.014249023728812408,-0.003400760354883808,-0.019553310044403843,-0.028081657004541193,-0.025828756054358606,-0.013774136878200989,0.0033855737768421173,0.01906479697462282,0.027314873855236274,0.025079470373926452,0.0133249578723919,-0.003371578577002923,-0.0186030323600268,-0.026589503608509014,-0.024370222654297162,-0.01289944499792349,0.0033586483021114167,0.01816586320510359,0.025902259166312447,0.023697869270739812,0.012495767211479679,-0.003346672705509794,-0.017751361450711965,-0.025250192326570428,-0.023059587338818334,-0.012112277655091735,0.0033355553171249747,0.01735779534957546,0.0246306512064508,0.02245283482643723,0.011747491068297852,-0.0033252114281390184,-0.016983605104012988,-0.024041243927155263,-0.02187531647405417,-0.011400064444426056,0.003315566411425927,0.016627382043497237,0.02347980751160371,0.021324954559734648,0.011068780400163883,-0.003306554315281792,-0.01628785075620152,-0.022944381142422733,-0.02079986372412198,-0.010752532824621325,0.003298116680811921,0.015963853696976654,0.02243318308335344,0.020298329212416474,0.010450314451522273,-0.0032902015431985126,-0.015654337880393054,-0.021944590691662356,-0.01981878800425976,-0.010161206060496421,0.00328276258491278,0.01535834333664347,0.021477123049106057,0.019359812394000933,0.00988436706362847,-0.0032757584149882267,-0.015074993063731617,-0.021029425819783135,-0.0189200956579959,-0.009619027274371875,0.0032691519533817525,0.014803484254502976,0.020600258008740227,0.018498439505864217,0.009364479689071874,-0.0032629099032424514,-0.014543080613712378,-0.02018848034868344,-0.018093743061929145,-0.00912007413874882,0.003257002297055657,0.014293105610354162,0.01979304508592873,0.01770499316347822,0.008885211691109967,-0.0032514021050499722,-0.014052936535059249,-0.019412986972785002,-0.017331255795841622,-0.008659339701404164,0.003246084896318319,0.013821999252707376,0.01904741530332501,0.016971668511844132,0.00844194742600425,-0.0032410285446719256,-0.013599763557169867,-0.018695506854219463,-0.016625433706132894,-0.008232562125508797,0.0032362129726280406,0.013385739049108336,0.01835649961286384,0.016291812633970833,0.008030745594752682,-0.003231619927960568,-0.013179471469369881,-0.01802968719223525,-0.015970120080109826,-0.007836091066189176,0.0032272327881880795,0.012980539430315071,0.017714413846320713,0.01565971959676806,0.007648220440558962,-0.003223036389054492,-0.012788551495575182,-0.01741007001210697,-0.015360019241083276,-0.007466781805232692,0.003219016873718083,0.01260314356568165,0.01711608831435302,0.015070467751965915,0.007291447205917437,-0.0032151615598177952,-0.01242397653281789,-0.016831939978056477,-0.01479055111439733,-0.0071219106420964745,0.0032114588220571024,0.012250734172934985,0.01655713160088301,0.014519789466139717,0.006957886260386776,-0.0032078979882478073,-0.012083121247654685,-0.016291202244120055,-0.014257734307674649,-0.006799106723426362,0.003204469247099955,0.011920861792014157,0.016033720806069417,0.014003965981270357,0.00664532173467389,-0.003201163566244387,-0.011763697567151385,-0.015784283646400936,-0.013758091389349213,-0.00649629670204585,0.0031979726192309485,0.011611386659702476,0.015542512433926393,0.013519741926087372,0.006351811525344912,-0.0031948887203763674,-0.01146370221192045,-0.015308052193662859,-0.013288571599333547,-0.0062116594943429386,0.0031919047665319956,0.011320431268515493,0.015080569531979117,0.013064255322745485,0.006075646285877538,-0.0031890141849221848,-0.011181373727871178,-0.0148597510211677,-0.012846487360393132,-0.005943589049772812,0.0031862108863668155,0.011046341386800988,0.014645301726977807,0.012634979908201567,0.005815315574503863,-0.003183489223230353,-0.010915157069230096,-0.01443694386456738,-0.012429461798371616,-0.005690663524641332,0.0031808439515949756,0.010787653830349962,0.014234415569991356,0.012229677314536917,0.0055694797429380145,-0.003178270197142987,-0.010663674228702324,-0.01403746977580583,-0.012035385106750649,-0.005451619610788872,0.0031757634243750866,0.010543069659548106,0.013845873180635225,0.011846357196644102,0.00533694646141234,-0.0031733194087608793,-0.010425699743560567,-0.013659405303668532,-0.011662378064114496,-0.00522533104078549,0.0031709342115422232,0.010311431765583433,0.013477857616027704,0.01148324380787106,0.005116651011826356,-0.003168604156869466,-0.010200140158711214,-0.013301032741814642,-0.011308761372944919,-0.005010790497862551,0.0031663258110615437,0.010091706029502013,0.013128743722402237,0.011138747839031213,0.004907639661768939,-0.003164095963733304,-0.009986016720524208,-0.012960813338204374,-0.010973029764128478,-0.004807094317597618,0.0031619116106340827,0.009882965406879052,0.012797073482752943,0.010811442578545,0.004709055571778544,-0.0031597699379892277,-0.009782450723637797,-0.01263736458443544,-0.010653830024801568,-0.004613429491328998,0.00315766830822887,0.009684376421486637,0.012481535071712575,0.010500043639444031,0.004520126796697779,-0.003155604246932816,-0.009588651048097438,-0.0123294408780486,-0.010349942273133982,-0.0044290625771676315,0.003153575430906623,0.009495187653031544,0.01218094498315565,0.010203391645776863,0.004340156026875548,-0.003151579677246577,-0.009403903514148725,-0.012035916987482284,-0.010060263933721138,-0.004253330199759775,0.0031496149333322386,0.009314719883745173,0.011894232717169365,0.009920437386380947,0.0041685117818388165,-0.0031476792676268534,-0.00922756175274757,-0.011755773856957943,-0.00978379596984657,-0.004085630879438947,0.003145770861242484,0.009142357631511758,0.011620427608768474,0.009650229035309477,0.004004620822052521,-0.0031438880001679456,-0.009059039345854477,-0.011488086373881289,-0.009519631010291936,-0.003925417978690644,0.003142029068130527,0.008977541847117246,0.011358647456836684,0.009391901110889398,0.0038479615866356515,-0.0031401925400036694,-0.008897803035129895,-0.011232012789342325,-0.009266943073358881,-0.0037721935916563555,0.003138376975742579,0.008819763593081861,0.01110808867262818,0.009144664903569825,0.0036980584987722216,-0.003136581014771224,-0.008743366833358714,-0.01098678553682697,-0.009024978642928807,-0.0036255032327911513,0.003134803370811257,0.008668558553521973,0.010868017716081948,0.008907800149544995,0.0035544770078541283,-0.00313304282708541,-0.008595286901644057,-0.010751703238195437,-0.0087930488934743,-0.0034849312053431263,0.003131298231892594,0.008523502250314794,0.010637763627733028,0.008680647765013344,0.003416819259505879,-0.003129568494495544,-0.008453157078657408,-0.010526123721589857,-0.008570522895066615,-0.003350096550261669,0.003127852581317167,0.008384205861783513,0.010416711496108446,0.008462603486725355,0.0032847203026405984,-0.003126149512411375,-0.008316604967128521,-0.010309457904912616,-0.008356821657233877,-0.0032206494924090856,0.0031244583581772783,0.008250312557189846,0.010204296726690465,0.008253112289619722,0.00315784475741559,-0.0031227782363185837,-0.00818528849819461,-0.010101164422221578,-0.008151412893289012,-0.0030962683142824222,0.003121108309002221,0.00812149427429574,0.01],"x":[-100.0,-99.7997997997998,-99.5995995995996,-99.39939939939939,-99.1991991991992,-98.998998998999,-98.7987987987988,-98.5985985985986,-98.3983983983984,-98.19819819819818,-97.997997997998,-97.7977977977978,-97.5975975975976,-97.39739739739738,-97.1971971971972,-96.99699699699698,-96.7967967967968,-96.5965965965966,-96.3963963963964,-96.19619619619618,-95.995995995996,-95.7957957957958,-95.5955955955956,-95.39539539539538,-95.1951951951952,-94.994994994995,-94.7947947947948,-94.5945945945946,-94.3943943943944,-94.19419419419418,-93.993993993994,-93.7937937937938,-93.5935935935936,-93.39339339339338,-93.1931931931932,-92.99299299299298,-92.7927927927928,-92.5925925925926,-92.3923923923924,-92.19219219219218,-91.991991991992,-91.7917917917918,-91.5915915915916,-91.39139139139138,-91.1911911911912,-90.990990990991,-90.7907907907908,-90.59059059059058,-90.3903903903904,-90.19019019019018,-89.98998998999,-89.7897897897898,-89.5895895895896,-89.38938938938938,-89.1891891891892,-88.98898898898898,-88.78878878878879,-88.58858858858858,-88.38838838838839,-88.18818818818818,-87.98798798798799,-87.78778778778779,-87.58758758758759,-87.38738738738738,-87.18718718718719,-86.98698698698699,-86.78678678678679,-86.58658658658658,-86.38638638638639,-86.18618618618618,-85.98598598598599,-85.78578578578579,-85.58558558558559,-85.38538538538538,-85.18518518518519,-84.98498498498498,-84.78478478478478,-84.58458458458458,-84.38438438438439,-84.18418418418418,-83.98398398398399,-83.78378378378378,-83.58358358358359,-83.38338338338338,-83.18318318318319,-82.98298298298299,-82.78278278278277,-82.58258258258257,-82.38238238238239,-82.18218218218217,-81.98198198198199,-81.78178178178177,-81.58158158158159,-81.38138138138137,-81.18118118118119,-80.98098098098097,-80.78078078078077,-80.58058058058057,-80.38038038038039,-80.18018018018017,-79.97997997997999,-79.77977977977977,-79.57957957957959,-79.37937937937937,-79.17917917917919,-78.97897897897899,-78.77877877877877,-78.57857857857857,-78.37837837837839,-78.17817817817817,-77.97797797797799,-77.77777777777777,-77.57757757757759,-77.37737737737737,-77.17717717717719,-76.97697697697697,-76.77677677677677,-76.57657657657657,-76.37637637637638,-76.17617617617617,-75.97597597597598,-75.77577577577577,-75.57557557557558,-75.37537537537537,-75.17517517517518,-74.97497497497498,-74.77477477477477,-74.57457457457457,-74.37437437437438,-74.17417417417417,-73.97397397397398,-73.77377377377377,-73.57357357357358,-73.37337337337337,-73.17317317317318,-72.97297297297297,-72.77277277277277,-72.57257257257257,-72.37237237237238,-72.17217217217217,-71.97197197197198,-71.77177177177177,-71.57157157157158,-71.37137137137137,-71.17117117117118,-70.97097097097098,-70.77077077077077,-70.57057057057057,-70.37037037037038,-70.17017017017017,-69.96996996996998,-69.76976976976977,-69.56956956956958,-69.36936936936937,-69.16916916916918,-68.96896896896897,-68.76876876876877,-68.56856856856857,-68.36836836836838,-68.16816816816817,-67.96796796796798,-67.76776776776777,-67.56756756756758,-67.36736736736736,-67.16716716716718,-66.96696696696698,-66.76676676676675,-66.56656656656656,-66.36636636636638,-66.16616616616616,-65.96596596596598,-65.76576576576576,-65.56556556556558,-65.36536536536536,-65.16516516516518,-64.96496496496496,-64.76476476476475,-64.56456456456456,-64.36436436436438,-64.16416416416416,-63.96396396396397,-63.76376376376376,-63.56356356356357,-63.36336336336336,-63.163163163163155,-62.962962962962976,-62.762762762762755,-62.56256256256256,-62.36236236236237,-62.16216216216216,-61.96196196196197,-61.76176176176176,-61.56156156156157,-61.36136136136136,-61.161161161161154,-60.96096096096096,-60.76076076076075,-60.56056056056056,-60.36036036036037,-60.16016016016016,-59.95995995995995,-59.75975975975976,-59.55955955955957,-59.35935935935936,-59.15915915915915,-58.95895895895896,-58.75875875875875,-58.55855855855856,-58.358358358358366,-58.15815815815816,-57.95795795795795,-57.75775775775776,-57.557557557557566,-57.35735735735736,-57.15715715715715,-56.95695695695696,-56.75675675675675,-56.55655655655656,-56.356356356356365,-56.15615615615616,-55.95595595595595,-55.75575575575576,-55.555555555555564,-55.35535535535536,-55.15515515515515,-54.95495495495496,-54.75475475475475,-54.55455455455456,-54.35435435435436,-54.154154154154156,-53.95395395395395,-53.753753753753756,-53.553553553553556,-53.353353353353356,-53.15315315315315,-52.952952952952955,-52.75275275275275,-52.552552552552555,-52.35235235235236,-52.152152152152155,-51.95195195195195,-51.751751751751755,-51.551551551551555,-51.351351351351354,-51.15115115115115,-50.950950950950954,-50.75075075075075,-50.550550550550554,-50.350350350350354,-50.150150150150154,-49.94994994994994,-49.74974974974975,-49.54954954954956,-49.34934934934935,-49.149149149149146,-48.94894894894895,-48.748748748748746,-48.54854854854855,-48.34834834834835,-48.14814814814815,-47.94794794794794,-47.74774774774775,-47.54754754754756,-47.34734734734735,-47.147147147147145,-46.94694694694695,-46.746746746746744,-46.54654654654654,-46.34634634634635,-46.14614614614615,-45.94594594594594,-45.74574574574575,-45.54554554554554,-45.34534534534535,-45.14514514514514,-44.94494494494495,-44.74474474474474,-44.544544544544536,-44.34434434434435,-44.14414414414415,-43.943943943943935,-43.74374374374375,-43.543543543543535,-43.34334334334335,-43.14314314314314,-42.94294294294295,-42.74274274274274,-42.542542542542535,-42.34234234234235,-42.14214214214215,-41.941941941941934,-41.74174174174175,-41.541541541541534,-41.34134134134135,-41.14114114114114,-40.94094094094095,-40.74074074074074,-40.54054054054053,-40.34034034034035,-40.14014014014014,-39.93993993993993,-39.73973973973975,-39.53953953953953,-39.33933933933935,-39.13913913913913,-38.938938938938946,-38.73873873873874,-38.53853853853853,-38.338338338338346,-38.13813813813814,-37.93793793793793,-37.737737737737746,-37.53753753753753,-37.337337337337345,-37.13713713713713,-36.936936936936945,-36.73673673673674,-36.53653653653653,-36.336336336336345,-36.13613613613614,-35.93593593593593,-35.735735735735744,-35.53553553553553,-35.335335335335344,-35.13513513513513,-34.93493493493494,-34.73473473473474,-34.53453453453452,-34.33433433433435,-34.134134134134136,-33.93393393393393,-33.733733733733736,-33.53353353353353,-33.33333333333334,-33.13313313313313,-32.932932932932935,-32.73273273273273,-32.53253253253252,-32.33233233233235,-32.132132132132135,-31.931931931931928,-31.731731731731735,-31.531531531531527,-31.33133133133134,-31.131131131131127,-30.930930930930934,-30.730730730730727,-30.53053053053052,-30.330330330330348,-30.130130130130134,-29.929929929929926,-29.729729729729733,-29.529529529529526,-29.32932932932934,-29.129129129129126,-28.928928928928933,-28.728728728728726,-28.52852852852852,-28.328328328328347,-28.128128128128132,-27.927927927927925,-27.727727727727732,-27.527527527527525,-27.327327327327325,-27.127127127127125,-26.926926926926924,-26.72672672672673,-26.526526526526517,-26.326326326326324,-26.126126126126124,-25.925925925925924,-25.72572572572573,-25.525525525525524,-25.325325325325323,-25.125125125125123,-24.924924924924923,-24.72472472472473,-24.524524524524516,-24.324324324324323,-24.124124124124123,-23.923923923923923,-23.72372372372373,-23.523523523523522,-23.323323323323322,-23.123123123123122,-22.922922922922922,-22.72272272272273,-22.522522522522515,-22.32232232232232,-22.12212212212212,-21.92192192192192,-21.721721721721728,-21.52152152152152,-21.32132132132132,-21.12112112112112,-20.920920920920913,-20.720720720720728,-20.520520520520513,-20.32032032032032,-20.12012012012012,-19.919919919919913,-19.719719719719727,-19.51951951951952,-19.31931931931932,-19.11911911911912,-18.918918918918912,-18.718718718718726,-18.518518518518512,-18.31831831831832,-18.11811811811812,-17.91791791791791,-17.717717717717726,-17.51751751751752,-17.31731731731732,-17.117117117117118,-16.91691691691691,-16.716716716716725,-16.51651651651651,-16.316316316316318,-16.116116116116117,-15.91591591591591,-15.715715715715724,-15.515515515515517,-15.315315315315317,-15.115115115115117,-14.91491491491491,-14.714714714714724,-14.514514514514502,-14.314314314314316,-14.114114114114116,-13.913913913913909,-13.713713713713723,-13.513513513513516,-13.313313313313316,-13.113113113113116,-12.912912912912908,-12.712712712712722,-12.512512512512501,-12.312312312312315,-12.112112112112115,-11.911911911911908,-11.711711711711722,-11.511511511511515,-11.311311311311314,-11.111111111111114,-10.910910910910907,-10.710710710710721,-10.5105105105105,-10.310310310310314,-10.110110110110114,-9.909909909909906,-9.70970970970972,-9.509509509509513,-9.309309309309313,-9.109109109109106,-8.908908908908906,-8.70870870870872,-8.508508508508498,-8.308308308308312,-8.108108108108105,-7.907907907907905,-7.707707707707719,-7.507507507507512,-7.307307307307312,-7.107107107107105,-6.9069069069069045,-6.7067067067067185,-6.506506506506497,-6.306306306306311,-6.106106106106104,-5.905905905905904,-5.705705705705718,-5.505505505505511,-5.3053053053053105,-5.105105105105103,-4.904904904904903,-4.704704704704717,-4.504504504504496,-4.30430430430431,-4.104104104104103,-3.9039039039039025,-3.7037037037037166,-3.5035035035035094,-3.3033033033033092,-3.103103103103102,-2.902902902902902,-2.7027027027026946,-2.5025025025024945,-2.3023023023023086,-2.1021021021021014,-1.9019019019019012,-1.701701701701694,-1.501501501501508,-1.301301301301308,-1.1011011011011007,-0.9009009009009006,-0.7007007007006933,-0.5005005005004932,-0.3003003003003073,-0.10010010010010006,0.10010010010010717,0.3003003003003073,0.5005005005004932,0.7007007007006933,0.9009009009008935,1.1011011011011078,1.301301301301308,1.501501501501508,1.701701701701694,1.9019019019018941,2.1021021021021085,2.3023023023023086,2.5025025025024945,2.7027027027026946,2.9029029029028948,3.103103103103109,3.3033033033033092,3.5035035035035094,3.7037037037036953,3.9039039039038954,4.10410410410411,4.30430430430431,4.504504504504496,4.704704704704696,4.904904904904896,5.10510510510511,5.3053053053053105,5.505505505505511,5.705705705705697,5.905905905905897,6.106106106106111,6.306306306306311,6.506506506506497,6.706706706706697,6.906906906906912,7.107107107107112,7.307307307307312,7.507507507507512,7.707707707707698,7.907907907907912,8.108108108108112,8.308308308308312,8.508508508508498,8.708708708708699,8.908908908908913,9.109109109109113,9.309309309309313,9.509509509509513,9.7097097097097,9.909909909909913,10.110110110110114,10.310310310310314,10.5105105105105,10.7107107107107,10.910910910910914,11.111111111111114,11.311311311311314,11.511511511511515,11.7117117117117,11.911911911911915,12.112112112112115,12.312312312312315,12.512512512512501,12.712712712712701,12.912912912912915,13.113113113113116,13.313313313313316,13.513513513513516,13.713713713713702,13.913913913913916,14.114114114114116,14.314314314314316,14.514514514514502,14.714714714714702,14.914914914914917,15.115115115115117,15.315315315315317,15.515515515515517,15.715715715715703,15.915915915915917,16.116116116116117,16.316316316316318,16.516516516516504,16.716716716716704,16.916916916916918,17.117117117117118,17.31731731731732,17.51751751751752,17.717717717717704,17.91791791791792,18.11811811811812,18.31831831831832,18.518518518518505,18.718718718718705,18.91891891891892,19.11911911911912,19.31931931931932,19.51951951951952,19.719719719719734,19.91991991991992,20.12012012012012,20.32032032032032,20.520520520520506,20.720720720720735,20.92092092092092,21.12112112112112,21.32132132132132,21.52152152152152,21.721721721721735,21.92192192192192,22.12212212212212,22.32232232232232,22.522522522522507,22.722722722722736,22.922922922922922,23.123123123123122,23.323323323323322,23.523523523523522,23.723723723723737,23.923923923923923,24.124124124124123,24.324324324324323,24.52452452452451,24.724724724724737,24.924924924924923,25.125125125125123,25.325325325325323,25.525525525525524,25.725725725725738,25.925925925925924,26.126126126126124,26.326326326326324,26.52652652652651,26.72672672672674,26.926926926926924,27.127127127127125,27.327327327327325,27.527527527527525,27.72772772772774,27.927927927927925,28.128128128128132,28.328328328328325,28.52852852852851,28.728728728728733,28.928928928928933,29.129129129129126,29.32932932932932,29.529529529529526,29.72972972972974,29.929929929929926,30.130130130130134,30.330330330330327,30.530530530530513,30.730730730730734,30.930930930930934,31.131131131131127,31.33133133133132,31.53153153153155,31.73173173173174,31.931931931931928,32.132132132132135,32.33233233233233,32.53253253253254,32.732732732732735,32.932932932932935,33.13313313313313,33.33333333333332,33.53353353353355,33.73373373373374,33.93393393393393,34.134134134134136,34.33433433433433,34.534534534534544,34.73473473473474,34.93493493493494,35.13513513513513,35.33533533533532,35.53553553553555,35.735735735735744,35.93593593593593,36.13613613613614,36.33633633633633,36.536536536536545,36.73673673673674,36.936936936936945,37.13713713713713,37.337337337337324,37.53753753753755,37.737737737737746,37.93793793793793,38.13813813813814,38.33833833833833,38.538538538538546,38.73873873873874,38.938938938938946,39.13913913913913,39.339339339339325,39.539539539539554,39.73973973973975,39.93993993993993,40.14014014014014,40.34034034034033,40.54054054054055,40.74074074074074,40.94094094094095,41.141141141141134,41.34134134134133,41.541541541541555,41.74174174174175,41.941941941941934,42.14214214214214,42.342342342342334,42.54254254254255,42.74274274274274,42.94294294294295,43.143143143143135,43.34334334334333,43.54354354354356,43.74374374374375,43.943943943943935,44.14414414414414,44.344344344344364,44.54454454454455,44.74474474474474,44.94494494494495,45.145145145145136,45.34534534534535,45.54554554554556,45.74574574574575,45.94594594594594,46.146146146146144,46.346346346346365,46.54654654654655,46.746746746746744,46.94694694694695,47.14714714714714,47.34734734734735,47.54754754754756,47.74774774774775,47.94794794794794,48.148148148148145,48.34834834834837,48.54854854854855,48.748748748748746,48.94894894894895,49.14914914914914,49.34934934934935,49.54954954954956,49.74974974974975,49.94994994994994,50.15015015015015,50.35035035035037,50.550550550550554,50.75075075075075,50.950950950950954,51.15115115115114,51.351351351351354,51.55155155155156,51.751751751751755,51.95195195195194,52.15215215215215,52.35235235235237,52.552552552552555,52.75275275275275,52.952952952952955,53.15315315315314,53.353353353353356,53.55355355355356,53.753753753753756,53.95395395395394,54.15415415415415,54.35435435435437,54.55455455455456,54.75475475475475,54.95495495495496,55.15515515515514,55.35535535535536,55.555555555555564,55.75575575575576,55.95595595595594,56.15615615615615,56.35635635635637,56.55655655655656,56.75675675675675,56.95695695695696,57.15715715715717,57.35735735735736,57.557557557557566,57.75775775775776,57.957957957957944,58.15815815815816,58.35835835835837,58.55855855855856,58.75875875875875,58.95895895895896,59.159159159159174,59.35935935935936,59.55955955955957,59.75975975975976,59.959959959959946,60.16016016016016,60.360360360360374,60.56056056056056,60.76076076076075,60.96096096096096,61.161161161161175,61.36136136136136,61.56156156156157,61.76176176176176,61.96196196196195,62.16216216216216,62.362362362362376,62.56256256256256,62.762762762762755,62.96296296296296,63.163163163163176,63.36336336336336,63.56356356356357,63.76376376376376,63.96396396396395,64.16416416416416,64.36436436436438,64.56456456456456,64.76476476476475,64.96496496496496,65.16516516516518,65.36536536536536,65.56556556556558,65.76576576576576,65.96596596596595,66.16616616616616,66.36636636636638,66.56656656656656,66.76676676676675,66.96696696696696,67.16716716716718,67.36736736736736,67.56756756756758,67.76776776776777,67.96796796796795,68.16816816816817,68.36836836836838,68.56856856856857,68.76876876876875,68.96896896896897,69.16916916916918,69.36936936936937,69.56956956956958,69.76976976976977,69.96996996996998,70.17017017017017,70.37037037037038,70.57057057057057,70.77077077077075,70.970970970971,71.17117117117118,71.37137137137137,71.57157157157158,71.77177177177177,71.97197197197198,72.17217217217217,72.37237237237238,72.57257257257257,72.77277277277275,72.97297297297297,73.17317317317318,73.37337337337337,73.57357357357358,73.77377377377377,73.97397397397398,74.17417417417417,74.37437437437438,74.57457457457457,74.77477477477476,74.974974974975,75.17517517517518,75.37537537537537,75.57557557557558,75.77577577577577,75.97597597597598,76.17617617617617,76.37637637637638,76.57657657657657,76.77677677677676,76.97697697697697,77.17717717717719,77.37737737737737,77.57757757757759,77.77777777777777,77.97797797797799,78.17817817817817,78.37837837837839,78.57857857857857,78.77877877877876,78.978978978979,79.17917917917919,79.37937937937937,79.57957957957959,79.77977977977977,79.97997997997999,80.18018018018017,80.38038038038039,80.58058058058057,80.78078078078076,80.98098098098097,81.18118118118119,81.38138138138137,81.58158158158159,81.7817817817818,81.98198198198199,82.18218218218217,82.38238238238239,82.58258258258257,82.78278278278279,82.982982982983,83.18318318318319,83.38338338338338,83.58358358358359,83.7837837837838,83.98398398398399,84.18418418418418,84.38438438438439,84.58458458458458,84.78478478478479,84.98498498498498,85.18518518518519,85.38538538538538,85.58558558558559,85.7857857857858,85.98598598598599,86.18618618618618,86.38638638638639,86.58658658658658,86.78678678678679,86.986986986987,87.18718718718719,87.38738738738738,87.58758758758759,87.7877877877878,87.98798798798799,88.18818818818818,88.38838838838839,88.58858858858858,88.78878878878879,88.98898898898898,89.1891891891892,89.38938938938938,89.5895895895896,89.78978978978981,89.98998998999,90.19019019019018,90.3903903903904,90.59059059059058,90.7907907907908,90.99099099099101,91.1911911911912,91.39139139139138,91.5915915915916,91.79179179179181,91.991991991992,92.19219219219218,92.3923923923924,92.59259259259258,92.7927927927928,92.99299299299298,93.1931931931932,93.39339339339338,93.5935935935936,93.79379379379381,93.993993993994,94.19419419419418,94.3943943943944,94.59459459459461,94.7947947947948,94.99499499499501,95.1951951951952,95.39539539539538,95.5955955955956,95.79579579579581,95.995995995996,96.19619619619618,96.3963963963964,96.59659659659661,96.7967967967968,96.99699699699698,97.1971971971972,97.39739739739738,97.5975975975976,97.79779779779781,97.997997997998,98.19819819819818,98.3983983983984,98.59859859859861,98.7987987987988,98.99899899899901,99.1991991991992,99.39939939939939,99.5995995995996,99.79979979979981,100.0]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_negative.json b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_negative.json
new file mode 100644
index 000000000000..f42ea6c60a5f
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_negative.json
@@ -0,0 +1 @@
+{"expected":[0.0013547037113347225,-8.079568762223632e-5,-0.0013032639667195508,0.0009482068870395127,0.0006745102501779502,-0.001398701036391261,0.000255111406170193,0.0012313462305848799,-0.0010749686633450609,-0.0005181201119181955,0.001421618557167307,-0.0004270214834770328,-0.0011399129246253466,0.001186335950670119,0.0003524234202627142,-0.001422922841085661,0.0005938738241728375,0.001030194114536836,-0.0012804704349696006,-0.0001798753787008332,0.001402405827825416,-0.0007530705608906795,-0.0009037097221535849,0.0013557809447669912,3.0571377722841856e-6,-0.0013601908085929216,0.00090210808806338,0.0007622488856180829,-0.0014109498242048327,0.0001753624225516151,0.001296733422985409,-0.001038616007954007,-0.0006078450522022653,0.001444955378254708,-0.00035266657261104876,-0.0012128176158849831,0.0011603943895038117,0.00044274714479023526,-0.0014570900164287276,0.0005261316848488993,0.0011095465725176972,-0.0012654487609877862,-0.0002693872052378724,0.0014469737831971222,-0.0006930686463983687,-0.000988328725870059,0.0013520222868438113,9.034497448861361e-5,-0.0014145630303815501,0.0008508641090431388,0.0008508590059255743,-0.0014186246169132317,9.169008045246035e-5,0.0013601540581324836,-0.0009970209502988333,-0.0006990955735166725,0.0014640569422268762,-0.00027395873965425173,-0.0012843816256292793,0.0011291973258823705,0.0005352323519173385,-0.0014874328448115696,0.00045367341552845337,0.0011882123093091032,-0.0012452437098237502,-0.0003616677354521192,0.0014881945889651262,-0.0006280603358161934,-0.0010729327640676513,0.0013432373436468015,0.00018096991543136698,-0.0014661245672588433,0.0007944018925442475,0.0009401330203414861,-0.0014215135501629114,4.160681355470407e-6,0.0014213516852222246,-0.0009500785172054345,-0.0007916850261118165,0.0014786934100405663,-0.00019093129845411082,-0.0013543525432043336,0.0010926094439603698,0.0006297167164960315,-0.0015137073498438882,0.0003764985165899695,0.0012659473512372733,-0.0012196917338994843,-0.00045658196359700174,0.001525814248009943,-0.0005580110665203211,-0.0011572905916701053,0.0013292369541027006,0.0002748268245898618,-0.0015146157294215843,0.0007326531501911984,0.001029856523769533,-0.0014194049353068075,-8.715256558205705e-5,0.0014800653889474682,-0.0008976876191456397,-0.0008854197031589855,0.0014886340709551128,-0.00010362400829770444,-0.0014224727585456776,0.0010504983554982849,0.0007260307657469528,-0.001535667667814884,0.00029461234075868443,0.0013425019101925,-0.0011886312069928156,-0.0005539877994905418,0.001559575913552348,-0.0004828914172042129,-0.0012411646668722214,0.0013098328436285595,0.0003718036967888423,-0.001559773088862306,0.0006655539214353752,0.0011198084749509854,-0.001412086929034473,-0.00018216994449885557,0.0015360297201346615,-0.0008397505962116547,-0.0009800990722715131,0.0014936470347427743,-1.2082633562067371e-5,-0.0014884794421916867,0.0010027341386315309,0.0008239981660159353,-0.0015530657694747935,0.00020802561615741247,0.0014176204183043272,-0.0011519019622018793,-0.0006537364115876184,0.0015892196477863452,-0.00040267659810687233,-0.0013243112453736956,0.0012848371684572191,0.00047178205726281007,-0.0016013292823055852,0.0005930440357804406,0.0012097613546304615,-0.0013993470919283144,-0.00028080568809054685,0.001588974550466894,-0.0007761726582254845,-0.00107551600129114,0.0014934988129685427,8.364156528367147e-5,-0.0015521044591576328,0.000949188762806971,0.0009234360190147962,-0.0015656510730402307,0.00011675388673029073,0.0014910415080325629,-0.0011093447096898986,-0.0007556725955325025,0.0016144820759963726,-0.0003173458452866235,-0.001406480433286962,0.0012540619351463758,0.0005746374032369982,-0.0016390127160546362,0.0005150664666649429,0.0012994812972225715,-0.0013809718196044682,-0.00038296849162276027,0.0016386248377328533,-0.0007068612053223135,-0.0011714569738001147,0.0014879537724229524,0.00018349241613511245,-0.0016130742041212014,0.0008897353845122248,0.0010241551652236242,-0.001573169931245789,2.0816860830323963e-5,0.00156249792648088,-0.0010608003173053836,-0.0008596351682610671,0.001635095919056224,-0.00022688170735919174,-0.0014874161892036053,0.001217318277087994,0.0006802396901033431,-0.0016725471560730281,0.00043156656309086347,0.0013887281884543937,-0.0013567456272531976,-0.000488562090991066,0.0016847002857268295,-0.0006317250129069342,-0.0012677022891250732,0.0014767734408503983,0.0002874095032710903,-0.0016711093432377332,0.0008242474956707887,0.0011259604917800746,-0.0015753649722662988,-7.976234294031766e-5,0.0016317163708284598,-0.0010061089341634364,-0.0009654573877765259,0.0016507893842002315,-0.0001312692109642274,-0.00156685626427808,0.00117441556658015,0.0007884538653761034,-0.001701651183686849,0.00034249114254462,0.001477255720185999,-0.001326450264943872,-0.0005974859112116129,0.001726914880121763,-0.0005506732619271132,-0.0013640262407515888,0.0014597156415146022,0.00039532892858763335,-0.001725924445297936,0.000752597903235873,0.0012286512418043039,-0.0015719742706545277,-0.00018495806565152034,0.0016984172294523322,-0.0009451089335665918,-0.0010729673989077332,0.00166128539029066,-3.0494888623187254e-5,-0.0016445320672257356,0.0011251603370159692,0.0008991404543097104,-0.0017260374936998097,0.00024778742560025563,0.0015648113920928586,-0.0012898636368181558,-0.0007096357929777119,0.001764976278206037,-0.000463614391745148,-0.0014601972660317963,0.001436533428745077,0.0005071841776274079,-0.001777227481767999,0.0006746575143988709,0.001332021321667042,-0.0015627303199562336,-0.0002947431093170613,0.0017623142104824195,-0.000877635647114571,-0.001181988705509238,0.0016663005993011269,7.545435059314086e-5,-0.0017201684387403934,0.0010693549848473762,0.0010121562019189667,-0.0017454120073065547,0.00014740178873852566,0.0016511364480105157,-0.001246758492097251,-0.0008249048065848175,0.001798585026165915,-0.0003704547484103538,-0.0015559780588202587,0.0014069737911778216,0.0006229071044089553,-0.0018247191713425983,0.0005902938967497829,0.001435859602146698,-0.0015473587731087077,-0.0004090898882778322,0.0018231138360421866,-0.0008035198562315358,-0.0012923406698205542,0.0016655442201935623,0.00018659253114648033,-0.0017934833168781646,0.0010067962149080379,0.0011273547772519725,-0.0017594727667576057,4.1278307103504146e-5,0.0017359657324537792,-0.0011969008493813384,-0.0009431841645044406,0.0018274335723977584,-0.0002710969955758156,-0.001651125635139938,0.0013707760827104086,0.0007424290519805919,-0.001868092139823284,0.0004993695764387755,0.0015399502087731067,-0.0015255769098995776,-0.0005279717534376103,0.00188051477612843,-0.0007225860004093342,-0.0014038390399978419,0.0016587165444956085,0.00030293613040504176,-0.0018641872713167583,0.0009372731851718193,0.0012445875471421256,-0.0017679085719836606,-7.064294701543132e-5,0.001819027449976398,-0.0011400481077436543,-0.0010643642464005965,0.0018512050388889978,-0.0001654382483686411,-0.0017453913400962337,0.0013276701328525117,0.0008656821293700336,-0.0019070298601474164,0.0004017400295716867,0.0016440727958308115,-0.0014970917822124433,-0.0006513645170384474,0.0019342069907288739,-0.0006346500528023691,-0.0015162965072519166,0.0016455071643315608,0.0004245058420226093,-0.0019319828798616812,0.0008605652976278972,0.0013637044283733614,-0.0017703973110033667,-0.00018842789163601208,0.0019000428065090883,-0.0010759467881396997,-0.001188335753541482,0.0018695717046640144,-5.336788189923322e-5,-0.0018385207818809972,0.0012773739777572454,0.0009926006702250087,-0.0019412053299193463,0.00029725131227621997,0.00174800279751675,-0.0014615979771500486,-0.0007792482118121494,0.00198387064209493,-0.0005395170029721808,-0.001629523294508763,0.001625592812960617,0.0005513286258136866,-0.0019965639149130804,0.0007764395702113349,0.001484554829378281,-0.001766603925403023,-0.00031215075946395925,0.001978725507397685,-0.0010043298361498826,-0.0013149910134954022,0.0018821931452065882,6.523504478390908e-5,-0.0019302536757935358,0.001219591140127759,0.0011231229042779956,-0.001970279434408502,0.00018573726256483899,0.001851511648473913,-0.0014187749246983114,-0.0009116091261997871,0.0020291747306822503,-0.0004369778729492942,-0.001743327779203361,0.0015986347543832497,0.0006834400964045517,-0.002057614300462889,0.0006846475099154906,0.0016069886953262006,-0.0017561779389238092,-0.0004418968219652154,0.0020547810812882607,-0.0009249134012767466,-0.0014442254610205064,0.0018887139590348678,0.0001905048221920631,-0.002020323577477306,0.001154007369698268,0.0012571928801717374,-0.0019938989311213094,6.701619155381206e-5,0.001954366964371656,-0.0013682836596523155,-0.0010484421671582108,0.0020697753976417236,-0.00032680617547555245,-0.0018575171536169687,0.001564275631522286,0.0008208873153478847,-0.0021148067911734235,0.0005849213883965001,0.0017308576739633779,-0.0017387504603642919,-0.0005777655908637214,0.002127905991959581,-0.0008373929879717024,-0.0015759393274072373,0.0018887609964432857,0.0003225926717121879,-0.0021084574798754777,0.0010802867349642938,0.0013947626875828087,-0.0020116939769745244,-5.911303823273265e-5,0.0020563326712172494,-0.0013097629259197934,-0.0011897536146932108,0.002105313823210916,-0.00020875370130126231,-0.00197189812728426,0.0015221356607012506,0.0009637320672407599,-0.0021678013135685873,0.00047696979744531783,0.0018560164240319333,-0.0017139305505457741,-0.0007198745938893114,0.0021977864911968854,-0.0007414388479511361,-0.0017100395786924557,0.0018819399847623138,0.0004616709873947697,-0.0021943752423986282,0.0009980669299919785,0.0015357950386406232,-0.00202327509979841,-0.00019287567512006143,0.0021571690695367557,-0.0012428244836755527,-0.0013355643483812275,0.0021354136330097853,-8.254549414101214e-5,-0.0020862776773738064,0.0014718080322355049,0.0011120547207017597,-0.002216242894596825,0.00036047233086623944,0.00198232409384313,-0.0016813008154827546,-0.0008683638461671332,0.0022640971542257833,-0.00063669045041512,-0.0018464421536345322,0.001867831417893785,0.0006079383796056533,-0.0022777888130631877,0.0009069536255053196,0.0016802662841747563,-0.002028229491022795,-0.00033452664148666346,0.002256632816310448,-0.0011670474441275649,-0.0014859136469816904,0.0021596777018512894,5.2126164564257466e-5,-0.002200463854752037,0.001412853340851707,0.0012659588013798802,-0.0022597590837185803,0.00023507319950193733,0.002109646005027644,-0.0016404120522090268,-0.0010234011704437892,0.0023264990242386147,-0.0005227498240863957,-0.001985074565928615,0.0018459855434035826,0.0007616256991975718,-0.002358401194327344,0.0008065136485331943,0.0018281699604804605,-0.0020261164640947796,-0.0004843572008295079,0.002354476803292009,-0.0010819714102669146,-0.0016408636893334996,0.0021776842155512427,0.00019560898640856122,-0.0023142666557930233,0.0013447928226674448,0.001425576438384721,-0.0022979567497804884,0.0001003735341873909,0.002237855586183085,-0.0015907767271146683,-0.0011851885608453183,0.0023846372729855944,-0.00039917350923353794,-0.0021258789528946767,0.0018159162354147217,0.0009230032695451527,-0.0024359050902366176,0.0006962667161434248,0.0019795209887001064,-0.002016461880903118,-0.0006427029872796444,0.002450449904790678,-0.000987088141197932,-0.0018005049202376323,0.0021889818130411405,0.0003482994098796178,-0.0024274989730836936,0.0012671001137905867,0.001591074890516702,-0.0023304181012462908,-4.407793676921038e-5,0.0023668366138935924,-0.0015318610054251371,-0.001353969839436181,0.002438138258662865,-0.00026546278450729853,-0.0022688156762298195,0.0017770934822175035,0.0010923896179530375,-0.002509981155198836,0.0005756753713357201,0.0021343606837077086,-0.0019987512926955397,-0.0008099537296424954,0.002544296560644756,-0.0008818313773363464,-0.0019649624919393944,0.002193083580590182,0.0005106532072058687,-0.0025399776422338678,0.0011791911639850528,0.0017626644181684891,-0.0023566957350428333,-0.00019879623938599445,0.0024964858354926006,-0.0014630749692552316,-0.0015300399272331895,0.0024866058281607277,-0.00012105173600641401,-0.002413867611434128,0.0017289341386814685,0.0012701620832088038,-0.002580295741700334,0.0004441326661138072,0.002292762775675713,-0.0019724214676949884,-0.0009865650998984584,0.0026357561503106584,-0.0007655643567502837,-0.002134404054368618,0.002189459602589621,0.0006831984439252842,-0.0026515246074161206,0.0010804118298362634,0.001940607846282311,-0.0023763064613720563,-0.00036437405972063864,0.0026267160704977212,-0.0013837605529489097,-0.0017137561482247505,0.0025296166649512093,3.47073944961511e-5,-0.0025610453040656998,0.00167079048782596,0.0014567697904262773,-0.002646498013376081,0.00030094699839199973,0.0024548407096762538,-0.0019368498777891524,-0.0011730732476570316,0.002724562100778038,-0.0006375644088929402,-0.00230904925143932,0.002177527682624515,0.0008665514188886104,-0.00276196823553134,0.0009700225248247034,0.0021252322709702327,-0.002388723573671563,-0.0005414988913268162,0.00275745991812455,-0.0012931765775929577,-0.001905552115924198,0.0025667144219387343,0.00020256232181616876,-0.00271039322720244,0.0016019360127129771,0.0016527496392926724,-0.002708216247919991,0.00014532332177049004,0.0026207565729647205,-0.001891341581119999,-0.0013701127606777705,0.0028104406530286142,-0.0004970038162398186,-0.002489181395139562,0.0021566417250685026,0.0010614364138116946,-0.0028711448187372303,0.0008471791034790378,0.002316943508528137,-0.00239336712625174,-0.000730974334831124,0.002888674239796538,-0.001190480065919487,-0.0021059549308931353,0.002597402293865043,0.0003833832712040953,-0.0028619974513478742,0.0015215475837377457,0.001858746163983543,-0.0027650530968247786,-2.3660310016934745e-5,0.0027907321151725097,-0.0018351127513961253,-0.0015784390367683198,0.002893109186976975,-0.0003429258653320415,-0.0026751619463645264,0.0021260770975594567,0.0012687103586072716,-0.002978900318566654,0.0007109088807818875,0.0025162440868568238,-0.0023895916350289443,-0.0009337467671138778,0.003020345642812623,-0.0010747027418019687,-0.0023156066647886274,0.002621133566636934,0.000578191288855563,-0.0030159951442838085,0.0014286829949344078,0.002075536416877019,-0.0028165794891526013,-0.00020708225886448164,0.002965062486857025,-0.001767269846441174,-0.0017989563928512285,0.0029722739702945705,-0.00017421463470532065,-0.0028674486500515845,0.0020850120581590564,0.001489393904630621,-0.00308509242353869,0.0005600803033804266,0.002723755860047883,-0.0023766704113479006,-0.0011509390262720404,0.0031524972711655,-0.0009447212311489741,-0.002535291452063633,0.0026372995168080443,0.0007881940917086166,-0.003172586467121874,0.001322252402236073,0.0023040614402272015,-0.0028623267544512165,-0.00040621477392281744,0.003144133546846729,-0.0016867830453416012,-0.0020327537157561223,0.00304762714776719,1.0443459467399459e-5,-0.00306661848006261,0.002032503997466113,0.0017247109421283146,-0.0031895930183453774,0.0003933642458390999,0.002940248723286922,-0.0023537754483585584,-0.0013838933649714404,0.003285197322313384,-0.0007992189323923819,-0.002765969999908602,0.002645213801524698,0.0010148319025046143,-0.0033320496437458063,0.0012009816759005773,0.0025454664754028687,-0.0029017763803050683,-0.0006225720274057844,0.003328443908914386,-0.0015924520660506687,-0.002281150141738545,0.0031188427180401414,0.00021260909091555514,-0.003273396988673426,0.001967458769034038,0.0019761393762924065,-0.003292291199888101,0.00020918412732333507,0.003166677473009642,-0.0023199513626289466,-0.001634226794578428,0.003418569870328527,-0.0006366367365831967,-0.0030088240303863967,0.0026440921439657436,0.001259836670615893,-0.0034947602842751633,0.00106336489986786,0.002801152903312241,-0.0029343465893604476,-0.0008579723517619142,0.003518633360445458,-0.0014828617267746986,-0.0025457542387467462,0.0031855711431955994,0.0004341542439747131,-0.0034886962922348742,0.0018885906894229385,0.0022454771055622153,-0.0033930970290242503,5.650913191548916e-6,0.0034042296826839315,-0.002274081286701297,-0.0019039032092638718,0.0035528088109410493,-0.00045510862731871024,-0.003265314194853117,0.0026330256291871613,0.001525309474325764,-0.003661216486495206,0.0009076021097272734,0.0030728461454490644,-0.002959374582048661,-0.0011146198246699294,0.0037155199635689026,-0.0013563235147126805,-0.002828541616136108,0.0032474320867874654,0.0006773466507477024,-0.0037136648619296303,0.001794369768372039,0.0025349288117075377,-0.0034919462853052786,-0.00021952260507948282,0.003654388684581852,-0.0022148417094277487,-0.0021953285551061063,0.003688196091642576,-0.00025237648509922117,-0.0035372565233596953,0.002610945196425019,0.0018138229740668472,-0.0038320718978704527,0.0007315166614991519,0.003362685595945985,-0.0029760927854200468,-0.0013952126006074046,0.003920149160636109,-0.0012107977810673696,-0.003131958056029521,0.0033040045506866306,0.000944962270464213,-0.003949753693213134,0.0016829511968555833,0.0028472216727159017,-0.0035888066087308573,-0.00046913637255812556,0.003919017583745334,-0.0021406419055430667,-0.002511478137680721,0.0038251259134398307,-2.5675843657797855e-5,-0.0038269247725934235,0.002576573809945749,0.002128558926620519,-0.004008179917679761,0.0005324440447493842,0.003673345448960945,-0.0029835966784503266,-0.0017030888132181358,0.004133859743939733,-0.0010437886748351805,-0.0034590585677355223,0.00335481333557082,0.0012404373066202104,-0.004198805573354954,0.0015520797741000489,0.0031857619399678462,-0.003683685589539909,-0.0007466584551358059,0.004200473047897748,-0.002049541510873125,-0.0028560695126706366,0.003964137394679675,0.00022841962692444207,-0.0041371895838354655,0.0025283610837442093,0.0024734956235669637,-0.004190653758641409,0.0003070799592868807,0.004008199614485716,-0.002980800567077187,-0.002042426191792385,0.00435837393752467,-0.0008522000264204298,-0.0038136979154346287,0.0033993102084415457,0.0015680769840596652,-0.004463177515213347,0.0013989582835377682,0.0035548503140859175,-0.0037766416410360635,-0.001056439274988003,0.004501762036534642,-0.0019391365208166402,-0.0032338012457680614,0.004105959449069065,0.0005142133977714651,-0.004471710956287773,0.002464392436606433,0.002853667788669086,-0.004380949519793147,5.1269145339538906e-5,0.004371550776810412,-0.0029663757776967714,-0.0024185199873416902,0.004595922632856262,-0.0006321341765750268,-0.004200796374251886,0.003436847291328398,0.001933347457112279,-0.004745911775827127,0.0012200629462801541,0.003959983656586401,-0.003867798924005024,-0.00140401244706331,0.004826761733952966,-0.0018063987061391982,-0.0036506888528963642,0.004251573658933453,0.0008371897247658115,-0.004835209581829987,0.0023822604782913538,0.0032755339015731314,-0.004580983361802023,-0.00024029382918976526,0.0047689548039375656,-0.002938662628690153,-0.0028381775827841385,0.004849423004116717,-0.0003786055833405128,-0.004626717888750534,0.0034666387522217686,0.0023432922254086382,-0.005050979654771991,0.0010108794041460108,0.004408286376083186,-0.003957368294961086,-0.0017965260083967498,0.00518053467388343,-0.001647444690657601,-0.0041145474877676315,0.0044023042767631845,0.0012044510685236647,-0.005233857607857714,0.0022788790314245853,0.0037475066359415068,-0.0047933004363489365,-0.0005744978182697404,0.0052076903706089125,-0.002895542315413201,-0.003310291279026129,0.005122736101896056,-8.512393347246296e-5,-0.005099820401838425,0.0034877044441906334,0.0028071397807017404,-0.005383637093464798,0.0007655162817272576,0.004909141618215516,-0.004045677424447422,-0.002243375119469975,0.005569790989575016,-0.0014571959950695425,-0.004635702115674285,0.004559950196676573,0.001625363493193764,-0.005675855138867132,0.0021502076378039853,0.004280737739178005,-0.005021324495129137,-0.000960458061786309,0.005697455868660591,-0.0028342457756060234,-0.0038466908083075258,0.005421049995493061,0.0002569282692790785,-0.0056312774346972,0.0034987848582336096,0.0033372134707137383,-0.005750956990830925,0.0004761246187804638,0.005475139369483325,-0.004133215252738831,-0.0027571553486115444,0.006003584843767947,-0.0012288649379601335,-0.005228061019195529,0.004726983799197774,0.0021125353435659565,-0.006172304493934396,0.001990832002869674,0.004890312209570127,-0.005269737180179002,-0.0014104976693112383,0.006251433354155071,-0.0027510602667391113,-0.004463449147864962,0.005751466336222101,0.0006592523885541026,-0.0062363410064963706,0.003498208933595754,0.003950334848852298,-0.0061626501236690875,0.00013199906500878158,0.006123544209342637,-0.004220699554409053,-0.0033551435657392724,0.006494396399085612,-0.0009531526966272212,-0.005910789848249327,0.004906860016925118,0.002683348909639368,-0.0067385787268572596,0.0017933042142779995,0.005597124605185778,-0.005545073236956974,-0.0019416955511766076,0.0068879669435177315,-0.0026408636819170864,-0.005182950281506819,0.006123928778520445,0.001138154612584251,-0.0069363498740341355,0.0034836813230158608,0.004670063887855653,-0.0066323755725485375,-0.00028186307557141835,0.006878648581299728,-0.004309183074290739,-0.004061681807401569,0.007059873870387264,-0.0006169522533267468,-0.006711018639932855,0.005104514344798969,0.003362447545308656,-0.007396544559638431,0.0015470654647428096,0.006430940058342965,-0.005856690308897225,-0.0025784227950037503,0.0076333139868096835,-0.0024963559927812327,-0.0060372936279061646,0.006552750954941695,0.0017170617784950542,-0.0077620524740952095,0.00345192562254963,0.005530422653822832,-0.007179919026460437,-0.0007871690515933735,0.007775704786464644,-0.004400226705934527,-0.004912179217464106,0.00772575893015032,-0.0002011587968342767,-0.007668410900046983,0.00532720005471089,0.0041859543335028716,-0.008178334646508282,0.0012366068812194428,0.007435615543206868,-0.006218420815770706,-0.0033566915953509562,0.008526364664715482,-0.002306730278512825,-0.007074165127271682,0.007059250483814296,0.0024308841484168816,-0.008759371974002448,0.0033980556552810483,0.006582390854060321,-0.00783499307304883,-0.0014165550912903857,0.008867827179055982,-0.004496194866173959,-0.005960176981576993,0.008531053351332805,0.00032322167973217875,-0.00884328286672188,0.005585968886779361,0.005209013447131068,-0.00913309493737129,0.0008381560025930381,0.008678497434581005,-0.006651540203159472,-0.004332032288489942,0.009627195972428613,-0.0020552409383400635,-0.008367546697812393,0.007676551537468152,0.0033340275687932723,-0.01],"x":[-709.0895,-708.481626247505,-707.87375249501,-707.265878742515,-706.65800499002,-706.050131237525,-705.4422574850299,-704.834383732535,-704.22650998004,-703.618636227545,-703.0107624750499,-702.402888722555,-701.7950149700599,-701.187141217565,-700.5792674650698,-699.9713937125749,-699.3635199600799,-698.755646207585,-698.1477724550898,-697.5398987025949,-696.9320249500998,-696.3241511976049,-695.7162774451098,-695.1084036926147,-694.5005299401198,-693.8926561876248,-693.2847824351297,-692.6769086826348,-692.0690349301399,-691.4611611776447,-690.8532874251497,-690.2454136726548,-689.6375399201598,-689.0296661676647,-688.4217924151696,-687.8139186626747,-687.2060449101798,-686.5981711576846,-685.9902974051896,-685.3824236526947,-684.7745499001998,-684.1666761477046,-683.5588023952096,-682.9509286427146,-682.3430548902195,-681.7351811377246,-681.1273073852296,-680.5194336327346,-679.9115598802395,-679.3036861277445,-678.6958123752496,-678.0879386227546,-677.4800648702594,-676.8721911177645,-676.2643173652696,-675.6564436127745,-675.0485698602794,-674.4406961077844,-673.8328223552895,-673.2249486027945,-672.6170748502993,-672.0092010978045,-671.4013273453095,-670.7934535928144,-670.1855798403194,-669.5777060878244,-668.9698323353294,-668.3619585828343,-667.7540848303394,-667.1462110778443,-666.5383373253494,-665.9304635728543,-665.3225898203593,-664.7147160678643,-664.1068423153694,-663.4989685628742,-662.8910948103793,-662.2832210578842,-661.6753473053892,-661.0674735528943,-660.4595998003992,-659.8517260479042,-659.2438522954093,-658.6359785429142,-658.0281047904192,-657.4202310379242,-656.8123572854292,-656.2044835329342,-655.5966097804392,-654.9887360279441,-654.3808622754491,-653.7729885229542,-653.1651147704591,-652.5572410179641,-651.949367265469,-651.3414935129741,-650.7336197604791,-650.1257460079842,-649.517872255489,-648.909998502994,-648.302124750499,-647.6942509980041,-647.086377245509,-646.478503493014,-645.870629740519,-645.2627559880241,-644.6548822355289,-644.0470084830339,-643.439134730539,-642.8312609780439,-642.2233872255489,-641.6155134730539,-641.007639720559,-640.3997659680639,-639.7918922155689,-639.1840184630739,-638.576144710579,-637.9682709580838,-637.3603972055888,-636.7525234530939,-636.1446497005988,-635.5367759481038,-634.9289021956088,-634.3210284431138,-633.7131546906189,-633.1052809381238,-632.4974071856287,-631.8895334331338,-631.2816596806388,-630.6737859281437,-630.0659121756488,-629.4580384231538,-628.8501646706586,-628.2422909181637,-627.6344171656688,-627.0265434131737,-626.4186696606786,-625.8107959081836,-625.2029221556887,-624.5950484031937,-623.9871746506985,-623.3793008982036,-622.7714271457087,-622.1635533932136,-621.5556796407185,-620.9478058882236,-620.3399321357286,-619.7320583832336,-619.1241846307386,-618.5163108782435,-617.9084371257486,-617.3005633732536,-616.6926896207585,-616.0848158682635,-615.4769421157685,-614.8690683632734,-614.2611946107785,-613.6533208582835,-613.0454471057885,-612.4375733532934,-611.8296996007984,-611.2218258483034,-610.6139520958084,-610.0060783433133,-609.3982045908184,-608.7903308383234,-608.1824570858284,-607.5745833333334,-606.9667095808384,-606.3588358283433,-605.7509620758484,-605.1430883233534,-604.5352145708583,-603.9273408183633,-603.3194670658684,-602.7115933133732,-602.1037195608783,-601.4958458083833,-600.8879720558882,-600.2800983033933,-599.6722245508982,-599.0643507984032,-598.4564770459082,-597.8486032934131,-597.2407295409182,-596.6328557884233,-596.0249820359281,-595.4171082834332,-594.8092345309382,-594.2013607784432,-593.5934870259481,-592.985613273453,-592.3777395209581,-591.7698657684632,-591.161992015968,-590.554118263473,-589.9462445109781,-589.338370758483,-588.730497005988,-588.122623253493,-587.5147495009982,-586.906875748503,-586.299001996008,-585.691128243513,-585.083254491018,-584.475380738523,-583.8675069860279,-583.259633233533,-582.6517594810381,-582.0438857285429,-581.4360119760479,-580.828138223553,-580.2202644710579,-579.6123907185629,-579.0045169660679,-578.3966432135729,-577.7887694610779,-577.1808957085829,-576.5730219560879,-575.9651482035929,-575.3572744510977,-574.7494006986028,-574.1415269461079,-573.5336531936128,-572.9257794411177,-572.3179056886228,-571.7100319361278,-571.1021581836328,-570.4942844311377,-569.8864106786427,-569.2785369261478,-568.6706631736528,-568.0627894211576,-567.4549156686627,-566.8470419161678,-566.2391681636727,-565.6312944111777,-565.0234206586827,-564.4155469061876,-563.8076731536926,-563.1997994011977,-562.5919256487026,-561.9840518962077,-561.3761781437125,-560.7683043912176,-560.1604306387226,-559.5525568862275,-558.9446831337325,-558.3368093812376,-557.7289356287425,-557.1210618762476,-556.5131881237525,-555.9053143712575,-555.2974406187625,-554.6895668662676,-554.0816931137725,-553.4738193612775,-552.8659456087825,-552.2580718562875,-551.6501981037924,-551.0423243512975,-550.4344505988024,-549.8265768463075,-549.2187030938125,-548.6108293413173,-548.0029555888224,-547.3950818363273,-546.7872080838323,-546.1793343313374,-545.5714605788424,-544.9635868263473,-544.3557130738524,-543.7478393213573,-543.1399655688624,-542.5320918163673,-541.9242180638722,-541.3163443113773,-540.7084705588824,-540.1005968063872,-539.4927230538923,-538.8848493013971,-538.2769755489023,-537.6691017964072,-537.0612280439123,-536.4533542914172,-535.8454805389222,-535.2376067864271,-534.6297330339321,-534.0218592814372,-533.4139855289421,-532.8061117764472,-532.1982380239521,-531.5903642714571,-530.9824905189621,-530.3746167664672,-529.766743013972,-529.1588692614771,-528.550995508982,-527.9431217564871,-527.3352480039921,-526.7273742514972,-526.119500499002,-525.5116267465071,-524.903752994012,-524.295879241517,-523.688005489022,-523.0801317365269,-522.472257984032,-521.864384231537,-521.2565104790419,-520.6486367265469,-520.040762974052,-519.4328892215569,-518.825015469062,-518.2171417165669,-517.6092679640719,-517.0013942115769,-516.3935204590819,-515.7856467065869,-515.1777729540919,-514.5698992015969,-513.9620254491018,-513.3541516966068,-512.7462779441119,-512.1384041916168,-511.5305304391218,-510.92265668662685,-510.3147829341317,-509.7069091816368,-509.09903542914174,-508.4911616766467,-507.8832879241518,-507.2754141716567,-506.6675404191617,-506.0596666666667,-505.4517929141717,-504.8439191616767,-504.23604540918166,-503.6281716566866,-503.0202979041917,-502.41242415169665,-501.8045503992016,-501.1966766467066,-500.5888028942116,-499.9809291417166,-499.37305538922163,-498.76518163672654,-498.1573078842316,-497.5494341317365,-496.94156037924154,-496.3336866267465,-495.72581287425146,-495.11793912175654,-494.5100653692615,-493.9021916167665,-493.29431786427153,-492.68644411177644,-492.07857035928146,-491.4706966067865,-490.86282285429144,-490.2549491017965,-489.64707534930136,-489.03920159680644,-488.4313278443114,-487.82345409181636,-487.2155803393214,-486.6077065868264,-485.99983283433136,-485.3919590818364,-484.7840853293413,-484.1762115768463,-483.5683378243513,-482.9604640718563,-482.35259031936135,-481.74471656686626,-481.1368428143713,-480.5289690618763,-479.92109530938126,-479.3132215568863,-478.70534780439124,-478.0974740518962,-477.4896002994013,-476.8817265469061,-476.2738527944112,-475.66597904191616,-475.0581052894212,-474.4502315369262,-473.8423577844312,-473.2344840319361,-472.62661027944114,-472.0187365269461,-471.4108627744512,-470.8029890219561,-470.1951152694611,-469.5872415169661,-468.9793677644711,-468.3714940119761,-467.7636202594811,-467.155746506986,-466.54787275449104,-465.93999900199606,-465.33212524950096,-464.7242514970061,-464.11637774451094,-463.508503992016,-462.900630239521,-462.29275648702594,-461.68488273453096,-461.077008982036,-460.46913522954094,-459.861261477046,-459.25338772455086,-458.64551397205594,-458.0376402195609,-457.42976646706586,-456.82189271457094,-456.21401896207584,-455.60614520958086,-454.9982714570859,-454.3903977045908,-453.78252395209586,-453.1746501996008,-452.5667764471058,-451.95890269461086,-451.3510289421157,-450.7431551896208,-450.13528143712574,-449.52740768463076,-448.9195339321358,-448.3116601796408,-447.7037864271457,-447.0959126746508,-446.4880389221557,-445.8801651696607,-445.27229141716566,-444.6644176646706,-444.0565439121757,-443.44867015968066,-442.8407964071857,-442.2329226546907,-441.6250489021956,-441.0171751497006,-440.40930139720564,-439.80142764471054,-439.1935538922156,-438.5856801397205,-437.9778063872256,-437.36993263473056,-436.7620588822355,-436.15418512974054,-435.54631137724556,-434.9384376247505,-434.3305638722556,-433.72269011976044,-433.11481636726546,-432.5069426147705,-431.8990688622755,-431.2911951097805,-430.6833213572854,-430.07544760479044,-429.46757385229546,-428.85970009980036,-428.2518263473055,-427.6439525948104,-427.03607884231536,-426.42820508982044,-425.8203313373253,-425.21245758483036,-424.6045838323353,-423.99671007984034,-423.38883632734536,-422.7809625748504,-422.1730888223553,-421.56521506986036,-420.95734131736526,-420.34946756487034,-419.74159381237524,-419.13372005988026,-418.5258463073853,-417.9179725548903,-417.31009880239526,-416.7022250499002,-416.0943512974052,-415.48647754491026,-414.8786037924152,-414.2707300399201,-413.6628562874252,-413.0549825349301,-412.4471087824352,-411.83923502994014,-411.2313612774451,-410.6234875249501,-410.01561377245514,-409.4077400199601,-408.7998662674652,-408.19199251497,-407.5841187624751,-406.97624500998006,-406.368371257485,-405.7604975049901,-405.15262375249506,-404.54475,-403.936876247505,-403.32900249500995,-402.72112874251496,-402.11325499002,-401.50538123752494,-400.89750748502996,-400.289633732535,-399.68175998003994,-399.0738862275449,-398.4660124750499,-397.85813872255494,-397.2502649700599,-396.64239121756486,-396.0345174650699,-395.4266437125749,-394.8187699600799,-394.2108962075848,-393.60302245508984,-392.99514870259486,-392.3872749500998,-391.7794011976048,-391.17152744510975,-390.56365369261476,-389.9557799401198,-389.3479061876248,-388.7400324351297,-388.1321586826347,-387.52428493013974,-386.91641117764476,-386.30853742514967,-385.7006636726547,-385.0927899201597,-384.4849161676647,-383.8770424151697,-383.26916866267464,-382.66129491017966,-382.0534211576847,-381.44554740518964,-380.8376736526946,-380.2297999001997,-379.6219261477046,-379.0140523952096,-378.4061786427146,-377.7983048902195,-377.19043113772454,-376.58255738522956,-375.9746836327346,-375.3668098802395,-374.75893612774456,-374.1510623752495,-373.5431886227545,-372.9353148702595,-372.3274411177645,-371.7195673652695,-371.11169361277445,-370.50381986027946,-369.8959461077845,-369.2880723552895,-368.6801986027944,-368.0723248502994,-367.4644510978044,-366.85657734530946,-366.24870359281437,-365.6408298403194,-365.03295608782435,-364.42508233532936,-363.8172085828344,-363.20933483033934,-362.6014610778443,-361.9935873253493,-361.38571357285434,-360.77783982035925,-360.16996606786427,-359.5620923153693,-358.9542185628743,-358.34634481037926,-357.7384710578842,-357.13059730538924,-356.52272355289426,-355.9148498003992,-355.3069760479042,-354.69910229540915,-354.0912285429142,-353.4833547904192,-352.8754810379242,-352.2676072854291,-351.6597335329342,-351.05185978043914,-350.4439860279441,-349.83611227544907,-349.22823852295414,-348.6203647704591,-348.01249101796407,-347.4046172654691,-346.7967435129741,-346.18886976047907,-345.580996007984,-344.97312225548905,-344.36524850299406,-343.7573747504991,-343.149500998004,-342.541627245509,-341.93375349301397,-341.325879740519,-340.71800598802395,-340.11013223552897,-339.5022584830339,-338.89438473053895,-338.28651097804396,-337.67863722554887,-337.0707634730539,-336.4628897205589,-335.8550159680639,-335.24714221556883,-334.63926846307385,-334.03139471057887,-333.4235209580839,-332.81564720558885,-332.2077734530938,-331.5998997005988,-330.99202594810384,-330.3841521956088,-329.77627844311377,-329.16840469061873,-328.5605309381238,-327.95265718562877,-327.3447834331338,-326.7369096806387,-326.1290359281437,-325.5211621756487,-324.91328842315374,-324.30541467065865,-323.69754091816367,-323.0896671656687,-322.48179341317365,-321.87391966067867,-321.2660459081837,-320.65817215568865,-320.0502984031936,-319.44242465069857,-318.8345508982036,-318.2266771457086,-317.61880339321357,-317.0109296407186,-316.40305588822355,-315.79518213572857,-315.1873083832336,-314.57943463073855,-313.9715608782435,-313.3636871257486,-312.75581337325355,-312.1479396207585,-311.54006586826347,-310.93219211576854,-310.3243183632735,-309.71644461077847,-309.10857085828343,-308.50069710578845,-307.89282335329347,-307.2849496007984,-306.6770758483034,-306.06920209580835,-305.4613283433134,-304.8534545908184,-304.24558083832335,-303.6377070858283,-303.0298333333334,-302.42195958083835,-301.8140858283433,-301.20621207584827,-300.59833832335335,-299.9904645708583,-299.38259081836327,-298.77471706586823,-298.1668433133733,-297.55896956087827,-296.95109580838323,-296.3432220558882,-295.73534830339327,-295.1274745508982,-294.5196007984032,-293.91172704590815,-293.30385329341317,-292.6959795409182,-292.08810578842315,-291.48023203592817,-290.87235828343313,-290.26448453093815,-289.65661077844317,-289.0487370259481,-288.4408632734531,-287.8329895209581,-287.22511576846307,-286.61724201596803,-286.00936826347305,-285.40149451097807,-284.79362075848303,-284.18574700598805,-283.577873253493,-282.96999950099803,-282.36212574850305,-281.754251996008,-281.14637824351297,-280.538504491018,-279.930630738523,-279.32275698602797,-278.71488323353293,-278.1070094810379,-277.49913572854297,-276.89126197604793,-276.2833882235529,-275.67551447105785,-275.06764071856287,-274.4597669660679,-273.85189321357285,-273.24401946107787,-272.6361457085829,-272.02827195608785,-271.42039820359287,-270.81252445109783,-270.2046506986028,-269.5967769461078,-268.9889031936128,-268.3810294411178,-267.77315568862275,-267.16528193612777,-266.55740818363273,-265.94953443113775,-265.3416606786427,-264.73378692614773,-264.12591317365275,-263.5180394211577,-262.91016566866267,-262.3022919161677,-261.6944181636727,-261.08654441117767,-260.47867065868263,-259.8707969061877,-259.26292315369267,-258.65504940119763,-258.0471756487026,-257.43930189620755,-256.83142814371257,-256.2235543912176,-255.61568063872255,-255.00780688622754,-254.3999331337326,-253.79205938123755,-253.1841856287425,-252.57631187624747,-251.96843812375255,-251.3605643712575,-250.75269061876247,-250.14481686626743,-249.53694311377248,-248.92906936127747,-248.32119560878243,-247.71332185628745,-247.10544810379247,-246.49757435129743,-245.8897005988024,-245.28182684630738,-244.67395309381234,-244.0660793413174,-243.45820558882238,-242.85033183632734,-242.24245808383233,-241.63458433133735,-241.0267105788423,-240.41883682634727,-239.8109630738523,-239.2030893213573,-238.59521556886227,-237.9873418163673,-237.37946806387225,-236.77159431137727,-236.16372055888226,-235.55584680638722,-234.9479730538922,-234.34009930139726,-233.73222554890222,-233.12435179640718,-232.51647804391217,-231.90860429141713,-231.30073053892218,-230.69285678642717,-230.08498303393213,-229.47710928143712,-228.86923552894217,-228.26136177644713,-227.6534880239521,-227.04561427145705,-226.43774051896213,-225.8298667664671,-225.22199301397205,-224.61411926147701,-224.00624550898206,-223.39837175648705,-222.790498003992,-222.18262425149697,-221.574750499002,-220.966876746507,-220.35900299401197,-219.75112924151696,-219.14325548902193,-218.53538173652697,-217.92750798403196,-217.31963423153692,-216.71176047904189,-216.10388672654693,-215.4960129740519,-214.88813922155686,-214.28026546906187,-213.6723917165669,-213.06451796407185,-212.45664421157687,-211.84877045908183,-211.24089670658685,-210.63302295409187,-210.02514920159683,-209.4172754491018,-208.80940169660676,-208.2015279441118,-207.5936541916168,-206.98578043912175,-206.37790668662672,-205.7700329341318,-205.16215918163675,-204.55428542914171,-203.94641167664668,-203.33853792415172,-202.7306641716567,-202.12279041916167,-201.51491666666664,-200.9070429141717,-200.29916916167667,-199.69129540918163,-199.0834216566866,-198.47554790419164,-197.86767415169663,-197.2598003992016,-196.65192664670658,-196.04405289421157,-195.4361791417166,-194.82830538922155,-194.22043163672652,-193.6125578842315,-193.00468413173655,-192.39681037924151,-191.7889366267465,-191.1810628742515,-190.5731891217565,-189.96531536926148,-189.3574416167665,-188.74956786427146,-188.14169411177647,-187.53382035928144,-186.92594660678643,-186.31807285429142,-185.71019910179643,-185.10232534930142,-184.4944515968064,-183.88657784431138,-183.27870409181634,-182.67083033932138,-182.06295658682637,-181.45508283433134,-180.8472090818363,-180.23933532934134,-179.63146157684633,-179.0235878243513,-178.41571407185626,-177.8078403193613,-177.1999665668663,-176.59209281437126,-175.98421906187622,-175.3763453093813,-174.76847155688625,-174.16059780439122,-173.55272405189618,-172.94485029940117,-172.33697654690621,-171.72910279441118,-171.12122904191617,-170.51335528942113,-169.90548153692617,-169.29760778443114,-168.6897340319361,-168.08186027944112,-167.47398652694613,-166.8661127744511,-166.2582390219561,-165.65036526946108,-165.0424915169661,-164.43461776447108,-163.82674401197605,-163.21887025948104,-162.61099650698606,-162.00312275449102,-161.395249001996,-160.787375249501,-160.17950149700596,-159.571627744511,-158.963753992016,-158.35588023952096,-157.74800648702592,-157.14013273453097,-156.53225898203593,-155.92438522954092,-155.31651147704588,-154.70863772455093,-154.10076397205592,-153.49289021956088,-152.88501646706584,-152.2771427145709,-151.66926896207588,-151.06139520958084,-150.4535214570858,-149.84564770459085,-149.23777395209584,-148.6299001996008,-148.02202644710576,-147.41415269461075,-146.8062789421158,-146.19840518962076,-145.59053143712575,-144.9826576846307,-144.37478393213576,-143.76691017964072,-143.1590364271457,-142.5511626746507,-141.94328892215572,-141.33541516966068,-140.72754141716567,-140.11966766467063,-139.51179391217568,-138.90392015968067,-138.29604640718563,-137.68817265469062,-137.08029890219564,-136.4724251497006,-135.8645513972056,-135.25667764471058,-134.64880389221554,-134.0409301397206,-133.43305638722555,-132.82518263473054,-132.2173088822355,-131.60943512974055,-131.00156137724554,-130.3936876247505,-129.78581387225546,-129.1779401197605,-128.5700663672655,-127.96219261477046,-127.35431886227542,-126.74644510978048,-126.13857135728546,-125.53069760479042,-124.9228238522954,-124.31495009980037,-123.7070763473054,-123.09920259481038,-122.49132884231537,-121.88345508982033,-121.27558133732538,-120.66770758483034,-120.05983383233531,-119.45196007984029,-118.84408632734534,-118.23621257485031,-117.62833882235529,-117.02046506986025,-116.4125913173653,-115.80471756487027,-115.19684381237525,-114.58897005988021,-113.98109630738526,-113.37322255489023,-112.76534880239521,-112.15747504990019,-111.54960129740516,-110.9417275449102,-110.33385379241518,-109.72598003992016,-109.11810628742512,-108.51023253493017,-107.90235878243513,-107.2944850299401,-106.68661127744508,-106.07873752495013,-105.4708637724551,-104.86299001996008,-104.25511626746504,-103.64724251497009,-103.03936876247506,-102.43149500998003,-101.823621257485,-101.21574750499005,-100.60787375249502,-100.0]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_positive.json b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_positive.json
new file mode 100644
index 000000000000..11d5c8b86c93
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/large_positive.json
@@ -0,0 +1 @@
+{"expected":[0.01,-0.0033746253790549624,-0.007622018879319136,0.00843349420704663,0.001889004559574812,-0.00959763287124854,0.004554864091885541,0.006437753655264493,-0.008809666729723751,-0.000468327621357804,0.009021878600127204,-0.005574489042175532,-0.005188845438344393,0.008984167322636266,-0.0008822361340235784,-0.008293387424072403,0.006423300008544822,0.00390249149724315,-0.008964910481678572,0.0021410030233847974,0.007434361161677098,-0.007094539111590877,-0.002605153786703288,0.0087627445091276,-0.0032889612155752985,-0.006468148173580897,0.007584861802057748,0.0013221736286423112,-0.008391166572328667,0.004309966210916771,0.005418829024186578,-0.007894256760515382,-7.741137080101638e-5,0.00786600339799083,-0.005190888286691567,-0.004310799964470551,0.008025916288409578,-0.0011070829665529621,-0.00720506320694166,0.0059217096985319595,0.003168361290995629,-0.007986059728650302,0.0022113627427645974,0.006427764980119337,-0.006495570438395232,-0.002015317447555855,0.007783713328832359,-0.003217836901260242,-0.005554751504162455,0.0069087623461371135,0.0008745954285802679,-0.007430450743094688,0.004111477604627807,0.004607492872683843,-0.007160672340873091,0.00023211237554265318,0.006940099051174486,-0.00487998044871584,-0.003607887217193065,0.007253676467270644,-0.0012846752729141803,-0.006328415747875719,0.005513875305599441,0.002577865411407692,-0.007192987327410233,0.0022648163001268594,0.005612742616618405,-0.006006586763021176,-0.00153900633791215,0.006986458278165674,-0.003156364877861086,-0.004811642742160233,0.006354444046560309,0.0005121690322926351,-0.006644348505237544,0.003945466543090177,0.003944527136917611,-0.006556641214801915,0.00048285236585137326,0.00617905372724083,-0.0046207470221406475,-0.0030312775513807594,0.006615149291794282,-0.0014276454140797583,-0.0056048078272581455,0.005173428759011166,0.002091872012714056,-0.006534582830377916,0.0023054630602133983,0.004937361147319414,-0.005597398884782191,-0.001146019489560075,0.006322024170613043,-0.003101470027877635,-0.0041936415074835445,0.005889228490530021,0.00021280982010589674,-0.005986809356747114,0.003802948422579008,0.0033914042216771465,-0.006048143932118084,0.0006896153286842611,0.005540280292535628,-0.0043994598664913835,-0.0025488774753354647,0.006075951734989388,-0.0015443651716269696,-0.004995508238426995,0.004882962287702354,0.00168440940535812,-0.005976919465789322,0.002336071445060531,0.00436699417707134,-0.005247880329196343,-0.0008161230833139685,0.005757615681360099,-0.0030511248715827765,-0.0036703518896386033,0.005491129188702217,-3.841464759629526e-5,-0.005426712741594785,0.0036778730471761206,0.002921979790357042,-0.005612092537049578,0.000862504886225179,0.004994756869438383,-0.004206777101008821,-0.002138727658395497,0.005612555974717905,-0.001640603793679084,-0.00447391034918145,0.0046305252678440646,0.0013375643846813207,-0.0054965982591913725,0.002358580514084293,0.0038776711650648425,-0.004944102324323375,-0.0005352527185069069,0.005270443255972749,-0.00300394190384798,-0.003220575689940079,0.005144814658170978,-0.00025196324112337605,-0.004942276221088488,0.0035660207544181725,0.002517890234124859,-0.005232271548429072,0.0010086524055568644,0.0045220286015450195,-0.004036124920484818,-0.0017852973554891482,0.0052083240203809455,-0.001720467938676326,-0.004021136032862671,0.004407645528211944,0.0010385828131245101,-0.005076963386680254,0.0023743909305575252,0.0034522746116722007,-0.004676123221830932,-0.000293328920583648,0.004844182283096554,-0.0029589426438823055,-0.002829080820353249,0.004839272196996332,-0.00043538017548502,-0.0045178016410455345,0.00346436212758138,0.002165860675781724,-0.004896962550898794,0.0011332360936155076,0.004107267598867109,-0.0038827466936394973,-0.001477293763266639,0.0048511622379739956,-0.0017869619136926833,-0.003623422830336836,0.004208153488994983,0.0007781377996418393,-0.0047058406422936004,0.0023845416920389327,0.0030782571544993855,-0.004436661150818149,-8.293924808176809e-5,0.004466836450524899,-0.0029154200873881494,-0.0024846425797872,0.00456639129577918,-0.000594244714662356,-0.004141693120883131,0.0033706690198681273,0.001856058123530432,-0.004597490347915314,0.0012401078946157153,0.003739465783277784,-0.003743118961844232,-0.0012063098334199075,0.004532072941424919,-0.0018423358607942092,-0.0032705038648665596,0.004027453169436852,0.0005492514201438184,-0.004374128830803134,0.0023898217124095522,0.0027462141060571542,-0.0042202638929197825,0.0001014892078418608,0.004129395888683835,-0.0028728532875289745,-0.00217880890909825,0.004320070339086488,-0.0007327724318554682,-0.003805202360141454,0.0032832688759818953,0.0015810451408777662,-0.004327298885133179,0.001332193664406734,0.0034102820608713055,-0.003614579152420938,-0.0009659585916019597,0.0042442267481438865,-0.0018883099676065614,-0.002954566646910545,0.003862053730280365,0.0003465992716145695,-0.004074890983889265,0.0023908426391146048,0.002448959438274671,-0.004022771440620501,0.00026422738837738403,0.0038249653113080315,-0.0028308523893974765,-0.001905095542674953,0.004095634147866093,-0.0008542085792725822,-0.003501607823646468,0.0032008843221029396,0.0013350931947512864,-0.004081344613809632,0.0014117568426470575,0.0031132831440029,-0.003495080560118109,-0.000751301299248045,0.0039823495988200956,-0.0019262233125530552,-0.002669563003554597,0.0037092590208347128,0.00016604814335501286,-0.003802750032448531,0.002388087749338463,0.0021809095582691345,-0.0038409575222056657,0.0004086038740077174,0.003548180682849912,-0.0027891221616012036,-0.0016584460091957547,0.0038894430832158615,-0.0009610928562494022,-0.003225662294979352,0.0031225253816182913,0.0011137192491966624,-0.003855686955326962,0.0014805770200375756,0.0028434296419308706,-0.003383026569449437,-0.0005584593235005616,0.0037423065725653787,-0.001957135328215383,-0.002410739334022185,0.0035669562592685992,4.340463089199636e-6,-0.003553476225131052,0.002381945611343005,0.0019376615497718379,-0.003672284215497602,0.0005372516695650078,0.003294808833358932,-0.0027474371465572647,-0.0014348600868823633,0.003698624023383261,-0.0010554420895805701,-0.0029732117153395644,0.003047415214307232,0.0009133652765595503,-0.0036472049859943957,0.0015400738095075364,0.0025967196933764074,-0.0032771557439615936,-0.0003843443595345254,0.003520812524978191,-0.001981896589820398,-0.0021743092640828243,0.0034334687762567285,-0.00014112611266398138,-0.003323698874081737,0.0023727337708766235,0.0017156978580311925,-0.0035147301018063157,0.0006522814102675338,0.0030614664015164317,-0.0027056243258361578,-0.0012311324328946071,0.003520881067978818,-0.0011388790574619577,-0.002740926389843438,0.0029749378100310943,0.000731171776015701,-0.0034533971691657716,0.001591394615566462,0.002369936531484166,-0.0031764604545482223,-0.00022646693702463983,0.0033152266358329277,-0.0020011992261728833,-0.0019572207568545287,0.0033074512487201294,-0.0002724558309912643,-0.0031107008045504225,0.0023607157449242115,0.001512175294614788,-0.0033666674657802775,0.000755405370044927,0.00284541857387878,-0.002663550773165199,-0.001044665065235685,0.0033543596961918744,-0.0012127251116146802,-0.0025261077201058865,0.002904600416141118,0.0005648146273983649,-0.0032722370521446977,0.0016354780062716367,0.002160466254018691,-0.003080128151737152,-8.2797930510248e-5,0.0031234037829790946,-0.002015613480508536,-0.00175698733817825,0.0031878137718127416,-0.0003913689234635678,-0.0029122690839324416,0.0023461134262499875,0.0013247715479910397,-0.003226772947196665,0.0008480278373982253,0.0026444323795080907,-0.0026211146941883907,-0.0008733304451358198,0.0031975475558126023,-0.0012780679337996755,-0.0023265468088722982,0.0028360060700227153,0.0004123855362317749,-0.003102067489642725,0.0016731002473195156,0.001966164025988275,-0.002987498252220287,4.833328785673103e-5,0.002943585209223255,-0.002025614663560462,-0.0015715637451245235,0.003073665910135281,-0.0004992857952449686,-0.002726584833597236,0.002329116279090795,0.0011515717076079153,-0.0030939614708401825,0.000931312039171034,0.002456668029433547,-0.002578238813341514,-0.0007153699145424307,0.0030492008505353272,-0.0013358118795590603,-0.002140419386636313,0.0027688331984681023,0.00027230306044425507,-0.0029415219008097995,0.0017049099941755753,0.00178525433166136,-0.0028980299980183146,0.00016831488624009116,0.0027743168705654368,-0.0020316033182356825,-0.0013992529276129048,0.002964274848589366,-0.0005973900770956858,-0.0025521406810003954,0.0023098882513615314,0.0009909831370971019,-0.002967336669599495,0.0010062304166468866,0.0022805972643783977,-0.0025348654174179044,-0.0005693172763382291,0.0029082889338595324,-0.0013867159137674443,-0.0019662066190262477,0.0027028202465123725,0.00014324546521498255,-0.0027894648250310636,0.001731454512834913,0.0016162555759663638,-0.0028112781592852815,0.0002783101226772472,0.002614387616968737,-0.002033920507690205,-0.0012386355507641765,0.0028590336609351694,-0.0006866764820938022,-0.002387678084620776,0.002288573035768586,0.000841670763073588,-0.0028461531856580177,0.001073602891775742,0.002114941187700384,-0.002490952588011033,-0.0004339405427495209,0.002773952060599716,-0.0014314225634398802,-0.0018026346487828543,0.0026377539430179966,2.4099403604626602e-5,-0.0026449464716311695,0.0017531997460879126,0.00145792236999857,-0.002726874431534224,0.00037930144622244026,0.002462781801289147,-0.002032859546961405,-0.0010885158914870888,0.0027574369494554997,-0.0007679875735687008,-0.002232139162713367,0.0022652981196188125,0.000702507285968018,-0.0027297876538164576,0.0011341263410876764,0.0019586223638287537,-0.00244647130004073,-0.0003081970043560719,0.002645468786255706,-0.00147048027338828,-0.0016486278957671848,0.002573460234211107,-8.607976421486679e-5,-0.002507167562224152,0.001770545845120164,0.0013092008421664524,-0.002644513025712797,0.0004721246781601332,0.0023186425320669743,-0.002028675104990842,-0.000947879846233412,0.0026590619294246404,-0.0008420423294057347,-0.0020846292530919777,0.002240177934078493,0.0005725344463660855,-0.002617716117379412,0.0011883975459047247,0.00181072750167585,-0.002401403159898697,-0.0001911981961946872,0.00252223053520494,-0.0015043608526036313,-0.0015032725941173386,0.0025097972004579777,-0.00018809898018439932,-0.002375451842558755,0.0017838393165831475,0.0011691936682457513,-0.0025639393856202934,0.0005574957818355751,0.002181242879348386,-0.00202159033766197,-0.0008158619997894686,0.0025635535866886197,-0.0009094585606008059,-0.0019443875126430056,0.002213316325692955,0.00045093258457585547,-0.002509496269414826,0.0012369312421345489,0.001670478089267887,-0.0023557386219282845,-8.218230752570724e-5,0.0024037215609318827,-0.0015334732230127411,-0.001365788039216979,0.002446649465264843,-0.0002826519588731703,-0.0022492243779544466,0.0017933826134722728,0.0010371324395293067,-0.002484941265751537,0.0006360320298354078,0.0020499630931021984,-0.0020118025292847827,-0.0006917195525119262,0.0024706129178784933,-0.0009707706722731069,-0.0018107636100686472,0.002184808512062408,0.000336996492845826,-0.002404753355323932,0.0012801744470596899,0.0015372070691704782,-0.0023094755667628676,1.9507746753487322e-5,0.002289503007619787,-0.0015581743520321108,-0.0012355037060267395,0.0023839237396364385,-0.00037033867283502197,-0.0021279942584769293,0.0017994417741892836,0.0009123556323570743,-0.002407341610307077,0.0007082688896389205,0.001924272416723798,-0.001999487592035099,-0.0005748114948750513,0.002379987528811685,-0.0010264438571449548,-0.0016831990860109252,0.0021547426407978825,0.00023011609295240618,-0.0023031688829249506,0.0013185179278611078,0.001410340151546865,-0.00226261815632344,0.00011444190350805529,0.0021792001238734966,-0.0015787780180434165,-0.0011118408849488351,0.002321545239227835,-0.0004516809982525571,-0.0020113407007840635,0.0018022525561288292,0.0007942908968149762,-0.0023309928205821405,0.0007746736043422663,0.00180371444766325,-0.0019848036822190554,-0.0004645818368192538,0.002291464054901176,-0.0010768855293036537,-0.0015612123237860743,0.0021232010403931414,0.00012976085036527882,-0.002204471506490353,0.0013523054543425155,0.0012893807223029294,-0.0022151759024297097,0.0002031171523614491,0.002072491922429874,-0.0015955618922985336,-0.0009942978268588042,0.002259454778879602,-0.0005271353749706217,-0.001898901791157,0.0018020253971051474,0.0006824407072981587,-0.0022557721026356895,0.000835656198416561,0.0016878952618040433,-0.0019678941272327347,-0.00036054599946802374,0.0022048620023513398,-0.001122454603471441,-0.0014443863389038776,0.0020902612296847677,3.54671083238826e-5,-0.0021084296094975655,0.0013818413183537387,0.0011738975633771888,-0.002167162901846324,0.0002859690931723308,0.0019691027549326263,-0.0016087733011967177,-0.000882437638330581,0.0021976063975728925,-0.0005971031245060763,-0.0017903653004235365,0.001798949456116054,0.0005763706527763578,-0.0021815776628847307,0.0008915784597271704,0.0015764737099661576,-0.0019488898098829778,-0.00026227969451200783,0.002120028706833006,-0.0011634690778397434,-0.00133235878806569,0.002055996736555185,-5.31722769552017e-5,-0.0020148452260280994,0.0014073964858683516,0.0010635147912839956,-0.002118597202116771,0.0003633814063964488,0.0018687953986439004,-0.001618633945617953,-0.0007758783501296759,0.002135965402175981,-0.0006619389156958007,-0.001685461137567241,0.0017931959250680322,0.0004756998166979747,-0.0021083255746908933,0.0009427613181347118,0.001469153435406946,-0.00192791112208511,-0.00016940977630202798,0.0020368351781634214,-0.001200212270439073,-0.0012248137397219514,0.0020204777647040138,-0.00013651647314981,-0.001923549025438211,0.0014292136619055039,0.0009579035592634622,-0.0020695002709836506,0.00043569366276668194,0.00177136534615375,-0.001625343789546472,-0.0006742847164405342,0.002074506744423042,-0.0007219577539746246,-0.0015839551094015958,0.0017849207587638026,0.0003800928237751474,-0.002035947179992053,0.0009894909439983506,0.0013656762652586982,-0.0019050695742462466,-8.160667009940467e-5,0.0019551726527607546,-0.0012329379787893553,-0.001121474853238804,0.001983771738528544,-0.0002148837458917894,-0.001834396147859251,0.0014475114846586616,0.0008567751719110644,-0.0020198965484688252,0.0005032078018536538,0.001676636059302045,-0.0016290842822227678,-0.0005773614024284432,0.002013213664976685,-0.0007774407854151666,-0.001485643728726439,0.0017742669373667639,0.00028925322595191566,-0.0019643869206406876,0.001032023817418387,0.00126581670664669,-0.0018804691274104883,1.4219314188499092e-6,0.0018749497155054894,-0.0012618747724839638,-0.0010220996923464246,0.0019459437495294306,-0.0002885573539847603,-0.0017472627252813008,0.0014624880173070333,0.0007598753389367104,-0.0019698130653723446,0.0005661935363351937,0.0015844550012379893,-0.0016300210419188286,-0.0004848472931187605,0.0019520765530275522,-0.0008286401427989321,-0.0013903498698960163,0.001761366350587126,0.0002029179715772622,-0.0018936005171811343,0.0010705909643593382,0.0011693773369633156,-0.0018542073006706367,7.993634436699407e-5,0.0017960898827375337,-0.0012872295828977296,-0.0009264749580346582,0.00190705692264887,-0.000357790488405239,-0.0016620429587037447,0.001474323669667731,0.0006669793535897241,-0.001919279115500805,0.0006248928836072154,0.0014946903005404878,-0.0016283061020082173,-0.00039651071375081354,0.0018910919809583453,-0.0008757830124216558,-0.0012979191136915354,0.001746341373859158,0.0001208527562862011,-0.0018235534303423309,0.0011054015141281398,0.0010761849224576526,-0.0018263760952868598,0.00015416933249715108,0.0017185295610630813,-0.0013091907195737175,-0.0008344124713796399,0.001867172717108242,-0.000422810430826549,-0.0015786466491034894,0.0014831836541463507,0.0005778880262993034,-0.0018683259716293663,0.0006795239841810711,0.0014072279318751817,-0.0016240797990220387,-0.0003121453955687333,0.0018302618820712844,-0.0009190750631916303,-0.0012082166562672975,0.0017293061922154342,4.284809591058868e-5,-0.001754219553962642,0.0011366457007582387,0.0009860871336266784,-0.0017970627684170263,0.00022432985947940388,0.001642216314245644,-0.0013279304161993703,-0.0007457457716739274,0.0018263511733559747,-0.00048382207139354474,-0.0014969971009479541,0.0014892200590753374,0.0004924242387303761,-0.0018169866372816216,0.000730284333815972,0.0013219693212441943,-0.0016174723661778823,-0.00023156705474265923,0.0017695928459084888,-0.0009587033508580503,-0.0011211246823498381,0.0017103679163291228,-3.128400599756564e-5,-0.0016855800984575933,0.0011644974061324103,0.000898949752385515,-0.0017663504827774893,0.00029060627506083647,0.0015671073840996523,-0.001343606988452704,-0.0006603272222014626,0.0017846511154448806,-0.0005410108975245877,-0.0014170293332391715,0.0014925736059851168,0.00041043001032005426,-0.0017652956280132586,0.0007773535310730766,0.0012388293021562836,-0.0016086052833111516,-0.00015461047837196556,0.001709095510765675,-0.0009948387879098184,-0.0010365401226006517,0.001689627526431842,-0.00010171289829495539,-0.0016176226320130786,0.0011891163234524363,0.0008146542866641094,-0.0017343188534058138,0.00035316903193835395,0.0014931684219097556,-0.0013563666699274509,-0.0005780255370831861,0.001742130316358363,-0.0005945455437270628,-0.001338688545766597,0.0014933751444063193,0.0003317639903813161,-0.0017132887771368966,0.0008208956222791876,0.0011577343633633864,-0.0015975924242773462,-8.112703202977462e-5,0.0016487840369650121,-0.0010276382522176027,-0.0009543727305231596,0.0016671806729632347,-0.0001685917126398524,-0.0015503402530236685,0.001210649804569881,0.0007330959242867455,-0.0017010444086675823,0.00041217301165898763,0.0014203723952454072,-0.0013663451796973138,-0.0004987236591255881,0.0016988456323976096,-0.000644579975265785,-0.0012619287982244068,0.0014917469276472496,0.00025629930533804004,-0.0016610030618090068,0.0008610611103393504,0.001078621140041301,-0.001584541035162512,-1.0982519468670268e-5,0.001588675647577043,-0.0010572463937177873,-0.0008745434264680063,0.0016431183573985153,-0.00023205945121231679,-0.0014837308722831706,0.0012292344428098056,0.0006541817707338699,-0.0016666009794538096,0.00046775952319085955,0.0013486986416117019,-0.0013736690651118403,-0.00042231693169361446,0.0016548531116204845,-0.000691255364999222,-0.0011867118677225319,0.0014878037049223778,0.00018392170375762488,-0.0016084764461720084,0.0008979886815637,0.0010014351092189444,-0.0015695525704905507,5.5944662075522775e-5,0.001528790225748818,-0.001083797187546618,-0.0007969828659627818,0.0016175275124054767,-0.0002922427865284056,-0.0014177965873931977,0.0012449974334534334,0.0005778293255745282,-0.0016310600279888488,0.0005200580262190576,0.0012781320456139377,-0.0013784568554704394,-0.00034871151800434745,0.0016102080804333118,-0.0007347017119009316,-0.0011130062565073524,0.0014816536588215525,0.00011452795221224462,-0.0015557477388619453,0.0009318066948678333,0.0009261294573486102,-0.0015527234097219994,0.00011976511736107152,0.001469149959770467,-0.001107415273301495,-0.0007216301972781652,0.0015904914970633767,-0.00034925761826916856,-0.001352543135020646,0.001258057746515065,0.00050396516042562,-0.0015944909256388358,0.0005691876218907034,0.0012086623204782844,-0.0013808200558933436,-0.0002778230295433546,0.0015649652117235575,-0.0007750392411754451,-0.0010407863267157488,0.0014733992119670871,4.8024443351145895e-5,-0.0015028564626855634,0.0009626344698868147,0.000852664093594242,-0.0015341454724189692,0.0001805798375757076,0.0014097790285858799,-0.0011282171131553429,-0.0006484319793389345,0.0015620905201192293,-0.00040321042418424137,-0.0012879794091582,0.0012685271403795335,0.00043252376782482155,-0.0015569611874856634,0.0006152583463028969,0.001140283378138073,-0.001380864005588963,-0.0002095753319935762,0.0015191785773454,-0.0008123796189428006,-0.0009700315430348594,0.0014631377225859693,-1.5674015746501023e-5,-0.0014498427346616828,0.0009905834041994542,0.0007810047870022236,-0.0015139067472927914,0.00023848140533292832,0.001350703321730001,-0.0011463119959023414,-0.0005773412360595602,0.001532402002046393,-0.0004541994357354287,-0.0012241170356022742,0.0012765110399913272,0.00036344655563969773,-0.0015185366701156824,0.000658372295973902,0.0010729927747985181,-0.0013786886206157503,-0.0001438995024418654,0.0014729016873053027,-0.0008468270088493829,-0.0009007258073856401,0.001450962085384556,-7.664526144318762e-5,-0.0013967471549453294,0.0010157579447764558,0.0007111224094082552,-0.0014920917477833327,0.00029355504647804795,0.001291950188696457,-0.0011618029094674705,-0.0005083166272206222,0.0015015008848669618,-0.0005023156640160524,-0.0011609699945040115,0.0012821092993090522,0.00029668096591077206,-0.0014792817380056282,0.000698624609657607,0.0010067912210914734,-0.0013743890378763429,-8.073291603006744e-5,0.0014261875176186092,-0.0008784789934290235,-0.0008328568724236371,0.0014369612513952016,-0.00013496069974191894,-0.0013436107034079628,0.001038256434588249,0.0006429922689646879,-0.0014687819047444288,0.0003458795506293845,0.0012335482135821156,-0.001174787300688789,-0.0004413217192995347,0.0014694598972368577,-0.0005476437972705667,-0.0010985542842114645,0.0012854168645085233,0.00023217970047910888,-0.0014392594030160633,0.0007361043268710619,0.0009416821477331842,-0.0013680561743604513,-2.001844377637972e-5,0.0013790885284927176,-0.0009074273792894457,-0.0007664158227911081,0.0014212206782551482,-0.00019068611930483717,-0.0012904746428634454,0.0010581718519219556,0.0005765935216221548,-0.0014440559051003127,0.00039552807880841544,0.0011755270115402297,-0.0011853577381613707,-0.00037632434233591893,0.0014363497810923871,-0.0005902629878833202,-0.001036887620716606,0.0012865243517794346,0.00016990003861119102,-0.0013985314407912817,0.0007708951402240088,0.0008776713190505759,-0.0013597772134087674,3.829625376194981e-5,0.0013316566742451231,-0.0009337589021892523,-0.0007013966148472324,0.0014038227205496864,-0.00024388240685085363,-0.0012373804280933014,0.0010755924571681343,0.0005119086499342708,-0.0014179899839424565,0.00044256887361214276,0.0011179170441271901,-0.0011936024914151245,-0.00031329602114875567,0.001402239485171366,-0.000630247543915065,-0.0009759891679376904,0.001285518551373567,0.00010980323415663845],"x":[100.0,100.60925648702595,101.21851297405189,101.82776946107784,102.43702594810378,103.04628243512974,103.65553892215569,104.26479540918164,104.87405189620759,105.48330838323353,106.09256487025948,106.70182135728543,107.31107784431137,107.92033433133733,108.52959081836327,109.13884730538923,109.74810379241518,110.35736027944112,110.96661676646706,111.57587325349301,112.18512974051896,112.7943862275449,113.40364271457086,114.01289920159681,114.62215568862275,115.2314121756487,115.84066866267464,116.44992514970059,117.05918163672655,117.66843812375251,118.27769461077844,118.8869510978044,119.49620758483034,120.10546407185629,120.71472055888223,121.32397704590818,121.93323353293414,122.54249001996008,123.15174650698603,123.76100299401197,124.37025948103793,124.97951596806388,125.58877245508982,126.19802894211577,126.80728542914171,127.41654191616766,128.02579840319362,128.63505489021955,129.2443113772455,129.85356786427147,130.4628243512974,131.07208083832336,131.6813373253493,132.29059381237525,132.8998502994012,133.50910678642714,134.1183632734531,134.72761976047906,135.33687624750502,135.94613273453092,136.55538922155688,137.16464570858284,137.7739021956088,138.38315868263473,138.9924151696607,139.60167165668662,140.21092814371258,140.82018463073854,141.42944111776447,142.0386976047904,142.6479540918164,143.25721057884232,143.86646706586828,144.4757235528942,145.08498003992017,145.6942365269461,146.30349301397206,146.91274950099802,147.52200598802395,148.1312624750499,148.74051896207584,149.3497754491018,149.95903193612776,150.5682884231537,151.17754491017965,151.78680139720558,152.39605788423154,153.0053143712575,153.61457085828343,154.2238273453094,154.83308383233532,155.44234031936128,156.05159680638724,156.66085329341317,157.2701097804391,157.87936626746506,158.48862275449102,159.09787924151698,159.70713572854294,160.31639221556887,160.9256487025948,161.53490518962076,162.14416167664672,162.75341816367268,163.3626746506986,163.97193113772454,164.5811876247505,165.19044411177646,165.79970059880242,166.40895708582835,167.01821357285428,167.62747005988024,168.2367265469062,168.84598303393213,169.45523952095806,170.06449600798402,170.67375249500998,171.28300898203594,171.8922654690619,172.50152195608783,173.11077844311376,173.72003493013972,174.32929141716568,174.9385479041916,175.54780439121757,176.1570608782435,176.76631736526946,177.37557385229542,177.98483033932135,178.5940868263473,179.20334331337324,179.8125998003992,180.42185628742516,181.03111277445112,181.64036926147705,182.24962574850298,182.85888223552894,183.4681387225549,184.07739520958086,184.6866516966068,185.29590818363275,185.90516467065868,186.51442115768464,187.1236776447106,187.73293413173653,188.3421906187625,188.95144710578842,189.56070359281438,190.1699600798403,190.77921656686624,191.3884730538922,191.99772954091816,192.60698602794412,193.21624251497008,193.82549900199604,194.43475548902197,195.0440119760479,195.65326846307386,196.26252495009982,196.87178143712578,197.4810379241517,198.09029441117764,198.6995508982036,199.30880738522956,199.9180638722555,200.52732035928142,201.13657684630738,201.74583333333334,202.3550898203593,202.9643463073852,203.57360279441116,204.18285928143715,204.79211576846308,205.40137225548904,206.010628742515,206.61988522954093,207.22914171656686,207.83839820359282,208.44765469061878,209.05691117764474,209.66616766467067,210.2754241516966,210.88468063872256,211.4939371257485,212.10319361277448,212.71245009980038,213.32170658682634,213.9309630738523,214.54021956087826,215.14947604790416,215.75873253493012,216.36798902195608,216.97724550898207,217.586501996008,218.19575848303396,218.8050149700599,219.41427145708585,220.02352794411178,220.63278443113774,221.24204091816367,221.85129740518965,222.46055389221556,223.06981037924152,223.67906686626745,224.2883233532934,224.89757984031934,225.5068363273453,226.11609281437126,226.72534930139722,227.33460578842318,227.94386227544908,228.55311876247504,229.162375249501,229.77163173652696,230.38088822355292,230.99014471057885,231.5994011976048,232.20865768463074,232.8179141716567,233.42717065868263,234.0364271457086,234.64568363273452,235.25494011976048,235.86419660678644,236.47345309381237,237.08270958083833,237.69196606786426,238.30122255489022,238.91047904191618,239.51973552894214,240.12899201596804,240.738248502994,241.34750499001996,241.95676147704592,242.56601796407188,243.17527445109783,243.78453093812377,244.39378742514972,245.00304391217566,245.61230039920162,246.22155688622755,246.8308133732535,247.44006986027944,248.0493263473054,248.65858283433133,249.2678393213573,249.87709580838322,250.48635229540918,251.09560878243514,251.7048652694611,252.314121756487,252.923378243513,253.53263473053892,254.14189121756488,254.75114770459078,255.3604041916168,255.96966067864273,256.5789171656687,257.1881736526946,257.7974301397206,258.4066866267465,259.01594311377244,259.6251996007984,260.23445608782436,260.8437125748503,261.4529690618763,262.06222554890223,262.67148203592814,263.2807385229541,263.88999500998005,264.499251497006,265.1085079840319,265.7177644710579,266.32702095808384,266.9362774451098,267.5455339321357,268.1547904191617,268.7640469061876,269.3733033932136,269.9825598802395,270.5918163672655,271.20107285429145,271.81032934131736,272.4195858283433,273.0288423153693,273.63809880239523,274.2473552894212,274.85661177644715,275.46586826347306,276.075124750499,276.684381237525,277.29363772455093,277.90289421157684,278.5121506986028,279.12140718562875,279.7306636726547,280.3399201596806,280.94917664670663,281.55843313373254,282.1676896207585,282.7769461077844,283.38620259481036,283.9954590818363,284.6047155688623,285.21397205588823,285.8232285429142,286.43248502994015,287.04174151696606,287.6509980039921,288.2602544910179,288.86951097804393,289.47876746506984,290.08802395209585,290.69728043912176,291.3065369261477,291.9157934131737,292.52504990019963,293.13430638722554,293.74356287425155,294.35281936127745,294.9620758483034,295.5713323353294,296.1805888223553,296.78984530938123,297.3991017964072,298.00835828343315,298.6176147704591,299.2268712574851,299.836127744511,300.44538423153693,301.05464071856284,301.66389720558885,302.27315369261476,302.8824101796407,303.4916666666667,304.10092315369263,304.71017964071854,305.3194361277445,305.92869261477045,306.53794910179647,307.1472055888223,307.75646207584833,308.3657185628743,308.9749750499002,309.58423153692615,310.1934880239521,310.8027445109781,311.41200099800403,312.02125748502993,312.6305139720559,313.23977045908185,313.84902694610776,314.4582834331338,315.0675399201597,315.67679640718563,316.2860528942116,316.89530938123755,317.50456586826346,318.1138223552894,318.7230788423154,319.33233532934133,319.9415918163673,320.5508483033932,321.1601047904192,321.7693612774451,322.3786177644711,322.987874251497,323.597130738523,324.20638722554895,324.81564371257485,325.42490019960076,326.0341566866268,326.6434131736527,327.25266966067863,327.8619261477046,328.47118263473055,329.0804391217565,329.6896956087824,330.2989520958084,330.90820858283433,331.5174650698603,332.1267215568862,332.7359780439122,333.3452345309381,333.95449101796413,334.56374750499003,335.173003992016,335.7822604790419,336.3915169660679,337.00077345309387,337.6100299401198,338.2192864271457,338.8285429141717,339.4377994011976,340.04705588822355,340.6563123752495,341.2655688622755,341.87482534930143,342.48408183632733,343.0933383233533,343.70259481037925,344.3118512974052,344.9211077844311,345.53036427145713,346.13962075848303,346.748877245509,347.3581337325349,347.9673902195609,348.5766467065868,349.1859031936128,349.7951596806387,350.4044161676647,351.0136726546906,351.6229291417166,352.2321856287425,352.8414421157685,353.45069860279443,354.0599550898204,354.66921157684635,355.27846806387225,355.8877245508982,356.4969810379242,357.10623752495013,357.71549401197603,358.32475049900205,358.93400698602795,359.5432634730539,360.1525199600798,360.76177644710583,361.37103293413173,361.9802894211577,362.5895459081836,363.1988023952096,363.8080588822355,364.4173153692615,365.0265718562874,365.6358283433134,366.24508483033935,366.85434131736525,367.4635978043912,368.0728542914172,368.6821107784432,369.29136726546903,369.90062375249505,370.50988023952095,371.11913672654697,371.7283932135729,372.33764970059883,372.94690618762473,373.55616267465075,374.16541916167665,374.7746756487026,375.3839321357285,375.99318862275453,376.60244510978043,377.2117015968064,377.8209580838323,378.4302145708583,379.03947105788427,379.6487275449102,380.25798403193613,380.8672405189621,381.47649700598805,382.08575349301395,382.69500998003997,383.3042664670659,383.91352295409183,384.52277944111773,385.13203592814375,385.74129241516965,386.35054890219567,386.9598053892215,387.56906187624753,388.17831836327343,388.78757485029945,389.39683133732535,390.0060878243513,390.6153443113772,391.22460079840323,391.8338572854292,392.4431137724551,393.0523702594811,393.661626746507,394.27088323353297,394.8801397205589,395.4893962075849,396.0986526946108,396.70790918163675,397.31716566866265,397.92642215568867,398.5356786427146,399.14493512974053,399.75419161676643,400.36344810379245,400.97270459081835,401.5819610778443,402.1912175648702,402.80047405189623,403.40973053892213,404.0189870259481,404.628243512974,405.2375,405.846756487026,406.45601297405193,407.06526946107783,407.6745259481038,408.2837824351298,408.8930389221557,409.5022954091816,410.1115518962076,410.7208083832336,411.3300648702595,411.93932135728545,412.54857784431135,413.15783433133737,413.7670908183633,414.37634730538923,414.98560379241513,415.59486027944115,416.20411676646705,416.813373253493,417.4226297405189,418.03188622754493,418.64114271457083,419.25039920159685,419.85965568862275,420.4689121756487,421.07816866267467,421.68742514970063,422.29668163672653,422.9059381237525,423.5151946107785,424.1244510978044,424.7337075848303,425.3429640718563,425.9522205588823,426.5614770459082,427.1707335329341,427.77999001996005,428.38924650698607,428.998502994012,429.6077594810379,430.21701596806383,430.82627245508985,431.43552894211575,432.04478542914177,432.65404191616767,433.26329840319363,433.8725548902196,434.48181137724555,435.09106786427145,435.7003243512974,436.30958083832337,436.91883732534933,437.52809381237523,438.1373502994012,438.74660678642715,439.3558632734531,439.965119760479,440.574376247505,441.183632734531,441.7928892215569,442.4021457085829,443.01140219560875,443.62065868263477,444.22991516966067,444.8391716566867,445.4484281437126,446.05768463073855,446.6669411177645,447.27619760479047,447.88545409181637,448.49471057884233,449.1039670658683,449.71322355289425,450.32248003992015,450.9317365269461,451.54099301397207,452.15024950099803,452.75950598802393,453.3687624750499,453.97801896207585,454.5872754491018,455.1965319361278,455.8057884231537,456.41504491017963,457.0243013972056,457.6335578842316,458.2428143712575,458.8520708582834,459.4613273453094,460.0705838323354,460.6798403193613,461.28909680638725,461.8983532934132,462.50760978043917,463.11686626746507,463.72612275449103,464.335379241517,464.94463572854295,465.55389221556885,466.1631487025948,466.77240518962077,467.38166167664673,467.9909181636727,468.6001746506986,469.20943113772455,469.8186876247505,470.42794411177647,471.03720059880243,471.64645708582833,472.25571357285435,472.8649700598803,473.4742265469062,474.0834830339321,474.6927395209581,475.3019960079841,475.91125249501,476.5205089820359,477.1297654690619,477.73902195608787,478.34827844311377,478.9575349301397,479.5667914171657,480.17604790419165,480.7853043912176,481.3945608782435,482.00381736526947,482.61307385229543,483.2223303393214,483.83158682634735,484.44084331337325,485.05009980039927,485.65935628742517,486.2686127744511,486.87786926147703,487.48712574850305,488.09638223552895,488.7056387225549,489.3148952095808,489.9241516966068,490.53340818363273,491.14266467065875,491.7519211576846,492.3611776447106,492.97043413173657,493.5796906187625,494.1889471057884,494.7982035928144,495.40746007984035,496.0167165668663,496.62597305389215,497.23522954091817,497.8444860279442,498.4537425149701,499.062999001996,499.67225548902195,500.28151197604797,500.89076846307387,501.50002495009977,502.10928143712573,502.71853792415175,503.32779441117765,503.93705089820367,504.5463073852295,505.1555638722555,505.76482035928143,506.37407684630745,506.9833333333333,507.5925898203593,508.2018463073852,508.8111027944112,509.4203592814371,510.0296157684631,510.638872255489,511.248128742515,511.8573852295409,512.4666417165669,513.0758982035928,513.6851546906188,514.2944111776446,514.9036676646707,515.5129241516967,516.1221806387226,516.7314371257486,517.3406936127744,517.9499500998004,518.5592065868263,519.1684630738523,519.7777195608783,520.3869760479042,520.9962325349302,521.6054890219561,522.214745508982,522.824001996008,523.4332584830339,524.0425149700599,524.6517714570858,525.2610279441118,525.8702844311377,526.4795409181637,527.0887974051896,527.6980538922156,528.3073103792415,528.9165668662675,529.5258233532935,530.1350798403193,530.7443363273453,531.3535928143713,531.9628493013972,532.5721057884232,533.1813622754491,533.7906187624751,534.3998752495011,535.0091317365269,535.6183882235529,536.2276447105788,536.8369011976048,537.4461576846307,538.0554141716567,538.6646706586827,539.2739271457086,539.8831836327346,540.4924401197604,541.1016966067864,541.7109530938125,542.3202095808384,542.9294660678643,543.5387225548902,544.1479790419162,544.7572355289421,545.366492015968,545.975748502994,546.58500499002,547.194261477046,547.8035179640718,548.4127744510978,549.0220309381239,549.6312874251497,550.2405439121756,550.8498003992015,551.4590568862276,552.0683133732535,552.6775698602795,553.2868263473055,553.8960828343314,554.5053393213573,555.1145958083832,555.7238522954092,556.3331087824351,556.9423652694611,557.5516217564871,558.160878243513,558.770134730539,559.3793912175648,559.9886477045908,560.5979041916167,561.2071606786427,561.8164171656687,562.4256736526946,563.0349301397206,563.6441866267465,564.2534431137724,564.8626996007984,565.4719560878244,566.0812125748503,566.6904690618762,567.2997255489023,567.9089820359283,568.5182385229541,569.1274950099801,569.736751497006,570.346007984032,570.9552644710578,571.5645209580838,572.1737774451099,572.7830339321358,573.3922904191617,574.0015469061876,574.6108033932136,575.2200598802395,575.8293163672654,576.4385728542914,577.0478293413174,577.6570858283434,578.2663423153692,578.8755988023953,579.4848552894211,580.0941117764471,580.7033682634731,581.312624750499,581.921881237525,582.531137724551,583.1403942115769,583.7496506986029,584.3589071856287,584.9681636726547,585.5774201596806,586.1866766467066,586.7959331337325,587.4051896207585,588.0144461077845,588.6237025948104,589.2329590818364,589.8422155688622,590.4514720558882,591.0607285429143,591.6699850299401,592.2792415169661,592.8884980039921,593.497754491018,594.107010978044,594.7162674650698,595.3255239520959,595.9347804391218,596.5440369261477,597.1532934131736,597.7625499001997,598.3718063872255,598.9810628742515,599.5903193612774,600.1995758483034,600.8088323353294,601.4180888223553,602.0273453093812,602.6366017964073,603.2458582834332,603.8551147704591,604.464371257485,605.073627744511,605.682884231537,606.2921407185629,606.9013972055889,607.5106536926148,608.1199101796408,608.7291666666666,609.3384231536927,609.9476796407185,610.5569361277445,611.1661926147705,611.7754491017964,612.3847055888224,612.9939620758483,613.6032185628742,614.2124750499003,614.8217315369261,615.4309880239521,616.040244510978,616.6495009980041,617.25875748503,617.8680139720559,618.4772704590819,619.0865269461078,619.6957834331337,620.3050399201596,620.9142964071857,621.5235528942117,622.1328093812375,622.7420658682635,623.3513223552895,623.9605788423154,624.5698353293412,625.1790918163672,625.7883483033933,626.3976047904192,627.0068612774452,627.616117764471,628.2253742514971,628.834630738523,629.4438872255489,630.0531437125749,630.6624001996008,631.2716566866268,631.8809131736527,632.4901696606787,633.0994261477047,633.7086826347305,634.3179391217565,634.9271956087824,635.5364520958084,636.1457085828343,636.7549650698603,637.3642215568864,637.9734780439122,638.5827345309381,639.191991017964,639.8012475049901,640.410503992016,641.0197604790419,641.6290169660679,642.2382734530939,642.8475299401198,643.4567864271457,644.0660429141716,644.6752994011977,645.2845558882235,645.8938123752495,646.5030688622755,647.1123253493015,647.7215818363273,648.3308383233533,648.9400948103793,649.5493512974052,650.1586077844312,650.767864271457,651.3771207584831,651.9863772455091,652.595633732535,653.2048902195609,653.8141467065868,654.4234031936128,655.0326596806387,655.6419161676647,656.2511726546907,656.8604291417166,657.4696856287426,658.0789421157685,658.6881986027944,659.2974550898203,659.9067115768463,660.5159680638723,661.1252245508982,661.7344810379242,662.3437375249501,662.9529940119761,663.5622504990021,664.1715069860279,664.7807634730539,665.3900199600799,665.9992764471058,666.6085329341317,667.2177894211577,667.8270459081837,668.4363023952096,669.0455588822355,669.6548153692614,670.2640718562875,670.8733283433133,671.4825848303393,672.0918413173654,672.7010978043913,673.3103542914172,673.919610778443,674.5288672654691,675.1381237524951,675.747380239521,676.3566367265469,676.9658932135729,677.5751497005989,678.1844061876247,678.7936626746506,679.4029191616767,680.0121756487026,680.6214321357286,681.2306886227544,681.8399451097805,682.4492015968065,683.0584580838323,683.6677145708584,684.2769710578842,684.8862275449102,685.4954840319361,686.1047405189621,686.7139970059881,687.323253493014,687.9325099800399,688.5417664670659,689.1510229540918,689.7602794411177,690.3695359281437,690.9787924151698,691.5880489021956,692.1973053892216,692.8065618762475,693.4158183632735,694.0250748502993,694.6343313373253,695.2435878243513,695.8528443113773,696.4621007984032,697.0713572854291,697.6806137724552,698.2898702594811,698.899126746507,699.5083832335329,700.1176397205589,700.7268962075849,701.3361526946109,701.9454091816367,702.5546656686628,703.1639221556886,703.7731786427146,704.3824351297404,704.9916916167665,705.6009481037925,706.2102045908184,706.8194610778443,707.4287175648703,708.0379740518962,708.6472305389221,709.2564870259481,709.8657435129741,710.475]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/runner.jl b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/runner.jl
new file mode 100644
index 000000000000..e9c90ea9d4a3
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/runner.jl
@@ -0,0 +1,80 @@
+#!/usr/bin/env julia
+#
+# @license Apache-2.0
+#
+# Copyright (c) 2018 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 JSON
+
+"""
+ gen( x, name )
+
+Generate fixture data and write to file.
+
+# Arguments
+
+* `x`: domain
+* `name::AbstractString`: output filename
+
+# Examples
+
+``` julia
+julia> x = range( -708, stop=709, length=2001 );
+julia> gen( x, \"data.json\" );
+```
+"""
+function gen( x, name )
+ y = cosc.( x );
+
+ # Store data to be written to file as a collection:
+ data = Dict([
+ ("x", x),
+ ("expected", y)
+ ]);
+
+ # Based on the script directory, create an output filepath:
+ filepath = joinpath( dir, name );
+
+ # Write the data to the output filepath as JSON:
+ outfile = open( filepath, "w" );
+ write( outfile, JSON.json(data) );
+ close( outfile );
+end
+
+# Get the filename:
+file = @__FILE__;
+
+# Extract the directory in which this file resides:
+dir = dirname( file );
+
+# Generate fixture data for decimal values:
+x = LinRange( -100, 100, 1000 );
+gen( x, "data.json" );
+
+# Large negative values:
+x = LinRange( -709.0895, -100, 1003 );
+gen( x, "large_negative.json" );
+
+# Large positive values:
+x = LinRange( 100, 710.475, 1003 );
+gen( x, "large_positive.json" );
+
+# Tiny negative values:
+x = rand(Float64, 10)*-10e-200;
+gen( x, "tiny_negative.json" );
+
+# Tiny positive values:
+x = rand(Float64, 10)*10e-200;
+gen( x, "tiny_positive.json" );
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_negative.json b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_negative.json
new file mode 100644
index 000000000000..85ca61c2cb45
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_negative.json
@@ -0,0 +1 @@
+{"expected":[-0.0,-0.0,-0.0,-0.0,-0.0,-0.0,-0.0,-0.0,-0.0,-0.0],"x":[-9.195873370788277e-200,-9.006868205451577e-200,-2.0302704881108302e-200,-4.697124158384864e-200,-4.52038739950706e-200,-2.1491068965578065e-201,-3.0590073997056775e-200,-3.835325822891831e-200,-7.378509868591106e-200,-7.233945087169975e-200]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_positive.json b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_positive.json
new file mode 100644
index 000000000000..ca26f1494b1b
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/fixtures/julia/tiny_positive.json
@@ -0,0 +1 @@
+{"expected":[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],"x":[7e-200,3.4561630239884523e-200,9.238493513228763e-201,7.329068948020792e-200,3.987926967580968e-201,3.412898694594113e-201,4e-200,4.178006140387547e-201,5.955777198110583e-200,5.736111313659942e-201]}
diff --git a/lib/node_modules/@stdlib/math/base/special/cosc/test/test.js b/lib/node_modules/@stdlib/math/base/special/cosc/test/test.js
new file mode 100644
index 000000000000..f89bea6a9880
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/cosc/test/test.js
@@ -0,0 +1,188 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2018 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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var PINF = require( '@stdlib/constants/math/float64-pinf' );
+var NINF = require( '@stdlib/constants/math/float64-ninf' );
+var EPS = require( '@stdlib/constants/math/float64-eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var cosc = require( './../lib' );
+
+
+// FIXTURES //
+
+var data = require( './fixtures/julia/data.json' );
+var largeNegative = require( './fixtures/julia/large_negative.json' );
+var largePositive = require( './fixtures/julia/large_positive.json' );
+var tinyNegative = require( './fixtures/julia/tiny_negative.json' );
+var tinyPositive = require( './fixtures/julia/tiny_positive.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.equal( typeof cosc, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function computes the derivative of the cardinal sine', function test( t ) {
+ var expected;
+ var delta;
+ var tol;
+ var x;
+ var y;
+ var i;
+
+ x = data.x;
+ expected = data.expected;
+
+ for ( i = 0; i < x.length; i++ ) {
+ y = cosc( x[i] );
+ if ( y === expected[ i ] ) {
+ t.equal( y, expected[ i ], 'x: '+x[i]+'. Expected: '+expected[i] );
+ } else {
+ delta = abs( y - expected[i] );
+ tol = 2.0 * EPS * abs( expected[i] );
+ t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. Expected: '+expected[i]+'. Tolerance: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'the function computes the derivative of the cardinal sine (large negative)', function test( t ) {
+ var expected;
+ var delta;
+ var tol;
+ var x;
+ var y;
+ var i;
+
+ x = largeNegative.x;
+ expected = largeNegative.expected;
+
+ for ( i = 0; i < x.length; i++ ) {
+ y = cosc( x[i] );
+ if ( y === expected[ i ] ) {
+ t.equal( y, expected[ i ], 'x: '+x[i]+'. Expected: '+expected[i] );
+ } else {
+ delta = abs( y - expected[i] );
+ tol = 2.0 * EPS * abs( expected[i] );
+ t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. Expected: '+expected[i]+'. Tolerance: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'the function computes the derivative of the cardinal sine (large positive)', function test( t ) {
+ var expected;
+ var delta;
+ var tol;
+ var x;
+ var y;
+ var i;
+
+ x = largePositive.x;
+ expected = largePositive.expected;
+
+ for ( i = 0; i < x.length; i++ ) {
+ y = cosc( x[i] );
+ if ( y === expected[ i ] ) {
+ t.equal( y, expected[ i ], 'x: '+x[i]+'. Expected: '+expected[i] );
+ } else {
+ delta = abs( y - expected[i] );
+ tol = 2.0 * EPS * abs( expected[i] );
+ t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. Expected: '+expected[i]+'. Tolerance: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'the function computes the derivative of the cardinal sine (tiny negative)', function test( t ) {
+ var expected;
+ var delta;
+ var tol;
+ var x;
+ var y;
+ var i;
+
+ x = tinyNegative.x;
+ expected = tinyNegative.expected;
+
+ for ( i = 0; i < x.length; i++ ) {
+ y = cosc( x[i] );
+ if ( y === expected[ i ] ) {
+ t.equal( y, expected[ i ], 'x: '+x[i]+'. Expected: '+expected[i] );
+ } else {
+ delta = abs( y - expected[i] );
+ tol = EPS * abs( expected[i] );
+ t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. Expected: '+expected[i]+'. Tolerance: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'the function computes the derivative of the cardinal sine (tiny positive)', function test( t ) {
+ var expected;
+ var delta;
+ var tol;
+ var x;
+ var y;
+ var i;
+
+ x = tinyPositive.x;
+ expected = tinyPositive.expected;
+
+ for ( i = 0; i < x.length; i++ ) {
+ y = cosc( x[i] );
+ if ( y === expected[ i ] ) {
+ t.equal( y, expected[ i ], 'x: '+x[i]+'. Expected: '+expected[i] );
+ } else {
+ delta = abs( y - expected[i] );
+ tol = EPS * abs( expected[i] );
+ t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. Expected: '+expected[i]+'. Tolerance: '+tol+'.' );
+ }
+ }
+ t.end();
+});
+
+tape( 'the function returns `NaN` if provided a `NaN`', function test( t ) {
+ var v = cosc( NaN );
+ t.equal( isnan( v ), true, 'returns NaN' );
+ t.end();
+});
+
+tape( 'the function returns `0.0` if provided `0.0`', function test( t ) {
+ var v = cosc( 0.0 );
+ t.equal( v, 0.0, 'returns 0.0' );
+ t.end();
+});
+
+tape( 'the function returns `0.0` if provided positive or negative infinity', function test( t ) {
+ var v = cosc( PINF );
+ t.equal( v, 0.0, 'returns 0.0' );
+
+ v = cosc( NINF );
+ t.equal( v, 0.0, 'returns 0.0' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/LICENSE b/lib/node_modules/@stdlib/namespace/alias2pkg/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/README.md b/lib/node_modules/@stdlib/namespace/alias2pkg/README.md
new file mode 100644
index 000000000000..ffcfce3d6ed8
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/README.md
@@ -0,0 +1,188 @@
+
+
+# alias2pkg
+
+> Return the package name associated with a specified alias.
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+```
+
+#### alias2pkg( alias )
+
+Returns the package name associated with a specified `alias`.
+
+```javascript
+var v = alias2pkg( 'base.sin' );
+// returns '@stdlib/math/base/special/sin'
+```
+
+If provided an unrecognized `alias`, the function returns `null`.
+
+```javascript
+var v = alias2pkg( 'unrecognized_alias_beep_boop_bop_bip' );
+// returns null
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+
+var list;
+var len;
+var idx;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ console.log( 'alias: %s. pkg: %s.', v, alias2pkg( v ) );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-alias2pkg [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-alias2pkg 'base.sin'
+@stdlib/math/base/special/sin
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/benchmark/benchmark.js b/lib/node_modules/@stdlib/namespace/alias2pkg/benchmark/benchmark.js
new file mode 100644
index 000000000000..894dfc31c382
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/benchmark/benchmark.js
@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var aliases = require( '@stdlib/namespace/aliases' );
+var pkg = require( './../package.json' ).name;
+var alias2pkg = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = aliases();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = alias2pkg( values[ i%values.length ] );
+ if ( typeof v !== 'string' ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/bin/cli b/lib/node_modules/@stdlib/namespace/alias2pkg/bin/cli
new file mode 100755
index 000000000000..a767303b3536
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/bin/cli
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var alias2pkg = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Resolve a provided alias to a package name...
+ out = alias2pkg( args[ 0 ] );
+ if ( out ) {
+ console.log( out ); // eslint-disable-line no-console
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv
new file mode 100644
index 000000000000..bed1410ced5d
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.csv
@@ -0,0 +1,1894 @@
+AFINN_96,"@stdlib/datasets/afinn-96"
+AFINN_111,"@stdlib/datasets/afinn-111"
+alias2pkg,"@stdlib/namespace/alias2pkg"
+alias2related,"@stdlib/namespace/alias2related"
+aliases,"@stdlib/namespace/aliases"
+allocUnsafe,"@stdlib/buffer/alloc-unsafe"
+anova1,"@stdlib/stats/anova1"
+ANSCOMBES_QUARTET,"@stdlib/datasets/anscombes-quartet"
+any,"@stdlib/utils/any"
+anyBy,"@stdlib/utils/any-by"
+anyByAsync,"@stdlib/utils/async/any-by"
+anyByRight,"@stdlib/utils/any-by-right"
+anyByRightAsync,"@stdlib/utils/async/any-by-right"
+APERY,"@stdlib/constants/math/float64-apery"
+append,"@stdlib/utils/append"
+ARCH,"@stdlib/os/arch"
+argumentFunction,"@stdlib/utils/argument-function"
+ARGV,"@stdlib/process/argv"
+array,"@stdlib/ndarray/array"
+array2buffer,"@stdlib/buffer/from-array"
+array2iterator,"@stdlib/array/to-iterator"
+array2iteratorRight,"@stdlib/array/to-iterator-right"
+ArrayBuffer,"@stdlib/array/buffer"
+arraybuffer2buffer,"@stdlib/buffer/from-arraybuffer"
+arrayCtors,"@stdlib/array/ctors"
+arrayDataType,"@stdlib/array/dtype"
+arrayDataTypes,"@stdlib/array/dtypes"
+arrayMinDataType,"@stdlib/array/min-dtype"
+arrayNextDataType,"@stdlib/array/next-dtype"
+arrayPromotionRules,"@stdlib/array/promotion-rules"
+arraySafeCasts,"@stdlib/array/safe-casts"
+arraySameKindCasts,"@stdlib/array/same-kind-casts"
+arrayShape,"@stdlib/array/shape"
+arrayStream,"@stdlib/streams/node/from-array"
+arrayview2iterator,"@stdlib/array/to-view-iterator"
+arrayview2iteratorRight,"@stdlib/array/to-view-iterator-right"
+AsyncIteratorSymbol,"@stdlib/symbol/async-iterator"
+bartlettTest,"@stdlib/stats/bartlett-test"
+base.abs,"@stdlib/math/base/special/abs"
+base.abs2,"@stdlib/math/base/special/abs2"
+base.absdiff,"@stdlib/math/base/utils/absolute-difference"
+base.absInt32,"@stdlib/math/base/special/int32-abs"
+base.acos,"@stdlib/math/base/special/acos"
+base.acosh,"@stdlib/math/base/special/acosh"
+base.acoth,"@stdlib/math/base/special/acoth"
+base.acovercos,"@stdlib/math/base/special/acovercos"
+base.acoversin,"@stdlib/math/base/special/acoversin"
+base.ahavercos,"@stdlib/math/base/special/ahavercos"
+base.ahaversin,"@stdlib/math/base/special/ahaversin"
+base.asin,"@stdlib/math/base/special/asin"
+base.asinh,"@stdlib/math/base/special/asinh"
+base.atan,"@stdlib/math/base/special/atan"
+base.atan2,"@stdlib/math/base/special/atan2"
+base.atanh,"@stdlib/math/base/special/atanh"
+base.avercos,"@stdlib/math/base/special/avercos"
+base.aversin,"@stdlib/math/base/special/aversin"
+base.bernoulli,"@stdlib/math/base/special/bernoulli"
+base.besselj0,"@stdlib/math/base/special/besselj0"
+base.besselj1,"@stdlib/math/base/special/besselj1"
+base.bessely0,"@stdlib/math/base/special/bessely0"
+base.bessely1,"@stdlib/math/base/special/bessely1"
+base.beta,"@stdlib/math/base/special/beta"
+base.betainc,"@stdlib/math/base/special/betainc"
+base.betaincinv,"@stdlib/math/base/special/betaincinv"
+base.betaln,"@stdlib/math/base/special/betaln"
+base.binet,"@stdlib/math/base/special/binet"
+base.binomcoef,"@stdlib/math/base/special/binomcoef"
+base.binomcoefln,"@stdlib/math/base/special/binomcoefln"
+base.boxcox,"@stdlib/math/base/special/boxcox"
+base.boxcox1p,"@stdlib/math/base/special/boxcox1p"
+base.boxcox1pinv,"@stdlib/math/base/special/boxcox1pinv"
+base.boxcoxinv,"@stdlib/math/base/special/boxcoxinv"
+base.cabs,"@stdlib/math/base/complex/abs"
+base.cabs2,"@stdlib/math/base/complex/abs2"
+base.cadd,"@stdlib/math/base/complex/add"
+base.cbrt,"@stdlib/math/base/special/cbrt"
+base.cceil,"@stdlib/math/base/complex/ceil"
+base.cceiln,"@stdlib/math/base/complex/ceiln"
+base.ccis,"@stdlib/math/base/complex/cis"
+base.cdiv,"@stdlib/math/base/complex/divide"
+base.ceil,"@stdlib/math/base/special/ceil"
+base.ceil2,"@stdlib/math/base/special/ceil2"
+base.ceil10,"@stdlib/math/base/special/ceil10"
+base.ceilb,"@stdlib/math/base/special/ceilb"
+base.ceiln,"@stdlib/math/base/special/ceiln"
+base.ceilsd,"@stdlib/math/base/special/ceilsd"
+base.cexp,"@stdlib/math/base/complex/exp"
+base.cflipsign,"@stdlib/math/base/complex/flipsign"
+base.cfloor,"@stdlib/math/base/complex/floor"
+base.cfloorn,"@stdlib/math/base/complex/floorn"
+base.cinv,"@stdlib/math/base/complex/inv"
+base.clamp,"@stdlib/math/base/special/clamp"
+base.cmul,"@stdlib/math/base/complex/multiply"
+base.cneg,"@stdlib/math/base/complex/negate"
+base.continuedFraction,"@stdlib/math/base/tools/continued-fraction"
+base.copysign,"@stdlib/math/base/special/copysign"
+base.cos,"@stdlib/math/base/special/cos"
+base.cosh,"@stdlib/math/base/special/cosh"
+base.cosm1,"@stdlib/math/base/special/cosm1"
+base.cospi,"@stdlib/math/base/special/cospi"
+base.covercos,"@stdlib/math/base/special/covercos"
+base.coversin,"@stdlib/math/base/special/coversin"
+base.cphase,"@stdlib/math/base/complex/phase"
+base.cpolar,"@stdlib/math/base/complex/polar"
+base.cround,"@stdlib/math/base/complex/round"
+base.croundn,"@stdlib/math/base/complex/roundn"
+base.csignum,"@stdlib/math/base/complex/signum"
+base.csub,"@stdlib/math/base/complex/subtract"
+base.dasum,"@stdlib/blas/base/dasum"
+base.daxpy,"@stdlib/blas/base/daxpy"
+base.dcopy,"@stdlib/blas/base/dcopy"
+base.deg2rad,"@stdlib/math/base/special/deg2rad"
+base.digamma,"@stdlib/math/base/special/digamma"
+base.diracDelta,"@stdlib/math/base/special/dirac-delta"
+base.dists.arcsine.Arcsine,"@stdlib/stats/base/dists/arcsine/ctor"
+base.dists.arcsine.cdf,"@stdlib/stats/base/dists/arcsine/cdf"
+base.dists.arcsine.entropy,"@stdlib/stats/base/dists/arcsine/entropy"
+base.dists.arcsine.kurtosis,"@stdlib/stats/base/dists/arcsine/kurtosis"
+base.dists.arcsine.logcdf,"@stdlib/stats/base/dists/arcsine/logcdf"
+base.dists.arcsine.logpdf,"@stdlib/stats/base/dists/arcsine/logpdf"
+base.dists.arcsine.mean,"@stdlib/stats/base/dists/arcsine/mean"
+base.dists.arcsine.median,"@stdlib/stats/base/dists/arcsine/median"
+base.dists.arcsine.mode,"@stdlib/stats/base/dists/arcsine/mode"
+base.dists.arcsine.pdf,"@stdlib/stats/base/dists/arcsine/pdf"
+base.dists.arcsine.quantile,"@stdlib/stats/base/dists/arcsine/quantile"
+base.dists.arcsine.skewness,"@stdlib/stats/base/dists/arcsine/skewness"
+base.dists.arcsine.stdev,"@stdlib/stats/base/dists/arcsine/stdev"
+base.dists.arcsine.variance,"@stdlib/stats/base/dists/arcsine/variance"
+base.dists.bernoulli.Bernoulli,"@stdlib/stats/base/dists/bernoulli/ctor"
+base.dists.bernoulli.cdf,"@stdlib/stats/base/dists/bernoulli/cdf"
+base.dists.bernoulli.entropy,"@stdlib/stats/base/dists/bernoulli/entropy"
+base.dists.bernoulli.kurtosis,"@stdlib/stats/base/dists/bernoulli/kurtosis"
+base.dists.bernoulli.mean,"@stdlib/stats/base/dists/bernoulli/mean"
+base.dists.bernoulli.median,"@stdlib/stats/base/dists/bernoulli/median"
+base.dists.bernoulli.mgf,"@stdlib/stats/base/dists/bernoulli/mgf"
+base.dists.bernoulli.mode,"@stdlib/stats/base/dists/bernoulli/mode"
+base.dists.bernoulli.pmf,"@stdlib/stats/base/dists/bernoulli/pmf"
+base.dists.bernoulli.quantile,"@stdlib/stats/base/dists/bernoulli/quantile"
+base.dists.bernoulli.skewness,"@stdlib/stats/base/dists/bernoulli/skewness"
+base.dists.bernoulli.stdev,"@stdlib/stats/base/dists/bernoulli/stdev"
+base.dists.bernoulli.variance,"@stdlib/stats/base/dists/bernoulli/variance"
+base.dists.beta.Beta,"@stdlib/stats/base/dists/beta/ctor"
+base.dists.beta.cdf,"@stdlib/stats/base/dists/beta/cdf"
+base.dists.beta.entropy,"@stdlib/stats/base/dists/beta/entropy"
+base.dists.beta.kurtosis,"@stdlib/stats/base/dists/beta/kurtosis"
+base.dists.beta.logcdf,"@stdlib/stats/base/dists/beta/logcdf"
+base.dists.beta.logpdf,"@stdlib/stats/base/dists/beta/logpdf"
+base.dists.beta.mean,"@stdlib/stats/base/dists/beta/mean"
+base.dists.beta.median,"@stdlib/stats/base/dists/beta/median"
+base.dists.beta.mgf,"@stdlib/stats/base/dists/beta/mgf"
+base.dists.beta.mode,"@stdlib/stats/base/dists/beta/mode"
+base.dists.beta.pdf,"@stdlib/stats/base/dists/beta/pdf"
+base.dists.beta.quantile,"@stdlib/stats/base/dists/beta/quantile"
+base.dists.beta.skewness,"@stdlib/stats/base/dists/beta/skewness"
+base.dists.beta.stdev,"@stdlib/stats/base/dists/beta/stdev"
+base.dists.beta.variance,"@stdlib/stats/base/dists/beta/variance"
+base.dists.betaprime.BetaPrime,"@stdlib/stats/base/dists/betaprime/ctor"
+base.dists.betaprime.cdf,"@stdlib/stats/base/dists/betaprime/cdf"
+base.dists.betaprime.kurtosis,"@stdlib/stats/base/dists/betaprime/kurtosis"
+base.dists.betaprime.logcdf,"@stdlib/stats/base/dists/betaprime/logcdf"
+base.dists.betaprime.logpdf,"@stdlib/stats/base/dists/betaprime/logpdf"
+base.dists.betaprime.mean,"@stdlib/stats/base/dists/betaprime/mean"
+base.dists.betaprime.mode,"@stdlib/stats/base/dists/betaprime/mode"
+base.dists.betaprime.pdf,"@stdlib/stats/base/dists/betaprime/pdf"
+base.dists.betaprime.quantile,"@stdlib/stats/base/dists/betaprime/quantile"
+base.dists.betaprime.skewness,"@stdlib/stats/base/dists/betaprime/skewness"
+base.dists.betaprime.stdev,"@stdlib/stats/base/dists/betaprime/stdev"
+base.dists.betaprime.variance,"@stdlib/stats/base/dists/betaprime/variance"
+base.dists.binomial.Binomial,"@stdlib/stats/base/dists/binomial/ctor"
+base.dists.binomial.cdf,"@stdlib/stats/base/dists/binomial/cdf"
+base.dists.binomial.entropy,"@stdlib/stats/base/dists/binomial/entropy"
+base.dists.binomial.kurtosis,"@stdlib/stats/base/dists/binomial/kurtosis"
+base.dists.binomial.logpmf,"@stdlib/stats/base/dists/binomial/logpmf"
+base.dists.binomial.mean,"@stdlib/stats/base/dists/binomial/mean"
+base.dists.binomial.median,"@stdlib/stats/base/dists/binomial/median"
+base.dists.binomial.mgf,"@stdlib/stats/base/dists/binomial/mgf"
+base.dists.binomial.mode,"@stdlib/stats/base/dists/binomial/mode"
+base.dists.binomial.pmf,"@stdlib/stats/base/dists/binomial/pmf"
+base.dists.binomial.quantile,"@stdlib/stats/base/dists/binomial/quantile"
+base.dists.binomial.skewness,"@stdlib/stats/base/dists/binomial/skewness"
+base.dists.binomial.stdev,"@stdlib/stats/base/dists/binomial/stdev"
+base.dists.binomial.variance,"@stdlib/stats/base/dists/binomial/variance"
+base.dists.cauchy.Cauchy,"@stdlib/stats/base/dists/cauchy/ctor"
+base.dists.cauchy.cdf,"@stdlib/stats/base/dists/cauchy/cdf"
+base.dists.cauchy.entropy,"@stdlib/stats/base/dists/cauchy/entropy"
+base.dists.cauchy.logcdf,"@stdlib/stats/base/dists/cauchy/logcdf"
+base.dists.cauchy.logpdf,"@stdlib/stats/base/dists/cauchy/logpdf"
+base.dists.cauchy.median,"@stdlib/stats/base/dists/cauchy/median"
+base.dists.cauchy.mode,"@stdlib/stats/base/dists/cauchy/mode"
+base.dists.cauchy.pdf,"@stdlib/stats/base/dists/cauchy/pdf"
+base.dists.cauchy.quantile,"@stdlib/stats/base/dists/cauchy/quantile"
+base.dists.chi.cdf,"@stdlib/stats/base/dists/chi/cdf"
+base.dists.chi.Chi,"@stdlib/stats/base/dists/chi/ctor"
+base.dists.chi.entropy,"@stdlib/stats/base/dists/chi/entropy"
+base.dists.chi.kurtosis,"@stdlib/stats/base/dists/chi/kurtosis"
+base.dists.chi.logpdf,"@stdlib/stats/base/dists/chi/logpdf"
+base.dists.chi.mean,"@stdlib/stats/base/dists/chi/mean"
+base.dists.chi.mode,"@stdlib/stats/base/dists/chi/mode"
+base.dists.chi.pdf,"@stdlib/stats/base/dists/chi/pdf"
+base.dists.chi.quantile,"@stdlib/stats/base/dists/chi/quantile"
+base.dists.chi.skewness,"@stdlib/stats/base/dists/chi/skewness"
+base.dists.chi.stdev,"@stdlib/stats/base/dists/chi/stdev"
+base.dists.chi.variance,"@stdlib/stats/base/dists/chi/variance"
+base.dists.chisquare.cdf,"@stdlib/stats/base/dists/chisquare/cdf"
+base.dists.chisquare.ChiSquare,"@stdlib/stats/base/dists/chisquare/ctor"
+base.dists.chisquare.entropy,"@stdlib/stats/base/dists/chisquare/entropy"
+base.dists.chisquare.kurtosis,"@stdlib/stats/base/dists/chisquare/kurtosis"
+base.dists.chisquare.logpdf,"@stdlib/stats/base/dists/chisquare/logpdf"
+base.dists.chisquare.mean,"@stdlib/stats/base/dists/chisquare/mean"
+base.dists.chisquare.mgf,"@stdlib/stats/base/dists/chisquare/mgf"
+base.dists.chisquare.mode,"@stdlib/stats/base/dists/chisquare/mode"
+base.dists.chisquare.pdf,"@stdlib/stats/base/dists/chisquare/pdf"
+base.dists.chisquare.quantile,"@stdlib/stats/base/dists/chisquare/quantile"
+base.dists.chisquare.skewness,"@stdlib/stats/base/dists/chisquare/skewness"
+base.dists.chisquare.stdev,"@stdlib/stats/base/dists/chisquare/stdev"
+base.dists.chisquare.variance,"@stdlib/stats/base/dists/chisquare/variance"
+base.dists.cosine.cdf,"@stdlib/stats/base/dists/cosine/cdf"
+base.dists.cosine.Cosine,"@stdlib/stats/base/dists/cosine/ctor"
+base.dists.cosine.kurtosis,"@stdlib/stats/base/dists/cosine/kurtosis"
+base.dists.cosine.logcdf,"@stdlib/stats/base/dists/cosine/logcdf"
+base.dists.cosine.logpdf,"@stdlib/stats/base/dists/cosine/logpdf"
+base.dists.cosine.mean,"@stdlib/stats/base/dists/cosine/mean"
+base.dists.cosine.median,"@stdlib/stats/base/dists/cosine/median"
+base.dists.cosine.mgf,"@stdlib/stats/base/dists/cosine/mgf"
+base.dists.cosine.mode,"@stdlib/stats/base/dists/cosine/mode"
+base.dists.cosine.pdf,"@stdlib/stats/base/dists/cosine/pdf"
+base.dists.cosine.quantile,"@stdlib/stats/base/dists/cosine/quantile"
+base.dists.cosine.skewness,"@stdlib/stats/base/dists/cosine/skewness"
+base.dists.cosine.stdev,"@stdlib/stats/base/dists/cosine/stdev"
+base.dists.cosine.variance,"@stdlib/stats/base/dists/cosine/variance"
+base.dists.degenerate.cdf,"@stdlib/stats/base/dists/degenerate/cdf"
+base.dists.degenerate.Degenerate,"@stdlib/stats/base/dists/degenerate/ctor"
+base.dists.degenerate.entropy,"@stdlib/stats/base/dists/degenerate/entropy"
+base.dists.degenerate.logcdf,"@stdlib/stats/base/dists/degenerate/logcdf"
+base.dists.degenerate.logpdf,"@stdlib/stats/base/dists/degenerate/logpdf"
+base.dists.degenerate.logpmf,"@stdlib/stats/base/dists/degenerate/logpmf"
+base.dists.degenerate.mean,"@stdlib/stats/base/dists/degenerate/mean"
+base.dists.degenerate.median,"@stdlib/stats/base/dists/degenerate/median"
+base.dists.degenerate.mgf,"@stdlib/stats/base/dists/degenerate/mgf"
+base.dists.degenerate.mode,"@stdlib/stats/base/dists/degenerate/mode"
+base.dists.degenerate.pdf,"@stdlib/stats/base/dists/degenerate/pdf"
+base.dists.degenerate.pmf,"@stdlib/stats/base/dists/degenerate/pmf"
+base.dists.degenerate.quantile,"@stdlib/stats/base/dists/degenerate/quantile"
+base.dists.degenerate.stdev,"@stdlib/stats/base/dists/degenerate/stdev"
+base.dists.degenerate.variance,"@stdlib/stats/base/dists/degenerate/variance"
+base.dists.discreteUniform.cdf,"@stdlib/stats/base/dists/discrete-uniform/cdf"
+base.dists.discreteUniform.DiscreteUniform,"@stdlib/stats/base/dists/discrete-uniform/ctor"
+base.dists.discreteUniform.kurtosis,"@stdlib/stats/base/dists/discrete-uniform/kurtosis"
+base.dists.discreteUniform.logcdf,"@stdlib/stats/base/dists/discrete-uniform/logcdf"
+base.dists.discreteUniform.logpmf,"@stdlib/stats/base/dists/discrete-uniform/logpmf"
+base.dists.discreteUniform.mean,"@stdlib/stats/base/dists/discrete-uniform/mean"
+base.dists.discreteUniform.median,"@stdlib/stats/base/dists/discrete-uniform/median"
+base.dists.discreteUniform.mgf,"@stdlib/stats/base/dists/discrete-uniform/mgf"
+base.dists.discreteUniform.pmf,"@stdlib/stats/base/dists/discrete-uniform/pmf"
+base.dists.discreteUniform.quantile,"@stdlib/stats/base/dists/discrete-uniform/quantile"
+base.dists.discreteUniform.skewness,"@stdlib/stats/base/dists/discrete-uniform/skewness"
+base.dists.discreteUniform.stdev,"@stdlib/stats/base/dists/discrete-uniform/stdev"
+base.dists.discreteUniform.variance,"@stdlib/stats/base/dists/discrete-uniform/variance"
+base.dists.erlang.cdf,"@stdlib/stats/base/dists/erlang/cdf"
+base.dists.erlang.entropy,"@stdlib/stats/base/dists/erlang/entropy"
+base.dists.erlang.Erlang,"@stdlib/stats/base/dists/erlang/ctor"
+base.dists.erlang.kurtosis,"@stdlib/stats/base/dists/erlang/kurtosis"
+base.dists.erlang.logpdf,"@stdlib/stats/base/dists/erlang/logpdf"
+base.dists.erlang.mean,"@stdlib/stats/base/dists/erlang/mean"
+base.dists.erlang.mgf,"@stdlib/stats/base/dists/erlang/mgf"
+base.dists.erlang.mode,"@stdlib/stats/base/dists/erlang/mode"
+base.dists.erlang.pdf,"@stdlib/stats/base/dists/erlang/pdf"
+base.dists.erlang.quantile,"@stdlib/stats/base/dists/erlang/quantile"
+base.dists.erlang.skewness,"@stdlib/stats/base/dists/erlang/skewness"
+base.dists.erlang.stdev,"@stdlib/stats/base/dists/erlang/stdev"
+base.dists.erlang.variance,"@stdlib/stats/base/dists/erlang/variance"
+base.dists.exponential.cdf,"@stdlib/stats/base/dists/exponential/cdf"
+base.dists.exponential.entropy,"@stdlib/stats/base/dists/exponential/entropy"
+base.dists.exponential.Exponential,"@stdlib/stats/base/dists/exponential/ctor"
+base.dists.exponential.kurtosis,"@stdlib/stats/base/dists/exponential/kurtosis"
+base.dists.exponential.logcdf,"@stdlib/stats/base/dists/exponential/logcdf"
+base.dists.exponential.logpdf,"@stdlib/stats/base/dists/exponential/logpdf"
+base.dists.exponential.mean,"@stdlib/stats/base/dists/exponential/mean"
+base.dists.exponential.median,"@stdlib/stats/base/dists/exponential/median"
+base.dists.exponential.mgf,"@stdlib/stats/base/dists/exponential/mgf"
+base.dists.exponential.mode,"@stdlib/stats/base/dists/exponential/mode"
+base.dists.exponential.pdf,"@stdlib/stats/base/dists/exponential/pdf"
+base.dists.exponential.quantile,"@stdlib/stats/base/dists/exponential/quantile"
+base.dists.exponential.skewness,"@stdlib/stats/base/dists/exponential/skewness"
+base.dists.exponential.stdev,"@stdlib/stats/base/dists/exponential/stdev"
+base.dists.exponential.variance,"@stdlib/stats/base/dists/exponential/variance"
+base.dists.f.cdf,"@stdlib/stats/base/dists/f/cdf"
+base.dists.f.entropy,"@stdlib/stats/base/dists/f/entropy"
+base.dists.f.F,"@stdlib/stats/base/dists/f/ctor"
+base.dists.f.kurtosis,"@stdlib/stats/base/dists/f/kurtosis"
+base.dists.f.mean,"@stdlib/stats/base/dists/f/mean"
+base.dists.f.mode,"@stdlib/stats/base/dists/f/mode"
+base.dists.f.pdf,"@stdlib/stats/base/dists/f/pdf"
+base.dists.f.quantile,"@stdlib/stats/base/dists/f/quantile"
+base.dists.f.skewness,"@stdlib/stats/base/dists/f/skewness"
+base.dists.f.stdev,"@stdlib/stats/base/dists/f/stdev"
+base.dists.f.variance,"@stdlib/stats/base/dists/f/variance"
+base.dists.frechet.cdf,"@stdlib/stats/base/dists/frechet/cdf"
+base.dists.frechet.entropy,"@stdlib/stats/base/dists/frechet/entropy"
+base.dists.frechet.Frechet,"@stdlib/stats/base/dists/frechet/ctor"
+base.dists.frechet.kurtosis,"@stdlib/stats/base/dists/frechet/kurtosis"
+base.dists.frechet.logcdf,"@stdlib/stats/base/dists/frechet/logcdf"
+base.dists.frechet.logpdf,"@stdlib/stats/base/dists/frechet/logpdf"
+base.dists.frechet.mean,"@stdlib/stats/base/dists/frechet/mean"
+base.dists.frechet.median,"@stdlib/stats/base/dists/frechet/median"
+base.dists.frechet.mode,"@stdlib/stats/base/dists/frechet/mode"
+base.dists.frechet.pdf,"@stdlib/stats/base/dists/frechet/pdf"
+base.dists.frechet.quantile,"@stdlib/stats/base/dists/frechet/quantile"
+base.dists.frechet.skewness,"@stdlib/stats/base/dists/frechet/skewness"
+base.dists.frechet.stdev,"@stdlib/stats/base/dists/frechet/stdev"
+base.dists.frechet.variance,"@stdlib/stats/base/dists/frechet/variance"
+base.dists.gamma.cdf,"@stdlib/stats/base/dists/gamma/cdf"
+base.dists.gamma.entropy,"@stdlib/stats/base/dists/gamma/entropy"
+base.dists.gamma.Gamma,"@stdlib/stats/base/dists/gamma/ctor"
+base.dists.gamma.kurtosis,"@stdlib/stats/base/dists/gamma/kurtosis"
+base.dists.gamma.logpdf,"@stdlib/stats/base/dists/gamma/logpdf"
+base.dists.gamma.mean,"@stdlib/stats/base/dists/gamma/mean"
+base.dists.gamma.mgf,"@stdlib/stats/base/dists/gamma/mgf"
+base.dists.gamma.mode,"@stdlib/stats/base/dists/gamma/mode"
+base.dists.gamma.pdf,"@stdlib/stats/base/dists/gamma/pdf"
+base.dists.gamma.quantile,"@stdlib/stats/base/dists/gamma/quantile"
+base.dists.gamma.skewness,"@stdlib/stats/base/dists/gamma/skewness"
+base.dists.gamma.stdev,"@stdlib/stats/base/dists/gamma/stdev"
+base.dists.gamma.variance,"@stdlib/stats/base/dists/gamma/variance"
+base.dists.geometric.cdf,"@stdlib/stats/base/dists/geometric/cdf"
+base.dists.geometric.entropy,"@stdlib/stats/base/dists/geometric/entropy"
+base.dists.geometric.Geometric,"@stdlib/stats/base/dists/geometric/ctor"
+base.dists.geometric.kurtosis,"@stdlib/stats/base/dists/geometric/kurtosis"
+base.dists.geometric.logcdf,"@stdlib/stats/base/dists/geometric/logcdf"
+base.dists.geometric.logpmf,"@stdlib/stats/base/dists/geometric/logpmf"
+base.dists.geometric.mean,"@stdlib/stats/base/dists/geometric/mean"
+base.dists.geometric.median,"@stdlib/stats/base/dists/geometric/median"
+base.dists.geometric.mgf,"@stdlib/stats/base/dists/geometric/mgf"
+base.dists.geometric.mode,"@stdlib/stats/base/dists/geometric/mode"
+base.dists.geometric.pmf,"@stdlib/stats/base/dists/geometric/pmf"
+base.dists.geometric.quantile,"@stdlib/stats/base/dists/geometric/quantile"
+base.dists.geometric.skewness,"@stdlib/stats/base/dists/geometric/skewness"
+base.dists.geometric.stdev,"@stdlib/stats/base/dists/geometric/stdev"
+base.dists.geometric.variance,"@stdlib/stats/base/dists/geometric/variance"
+base.dists.gumbel.cdf,"@stdlib/stats/base/dists/gumbel/cdf"
+base.dists.gumbel.entropy,"@stdlib/stats/base/dists/gumbel/entropy"
+base.dists.gumbel.Gumbel,"@stdlib/stats/base/dists/gumbel/ctor"
+base.dists.gumbel.kurtosis,"@stdlib/stats/base/dists/gumbel/kurtosis"
+base.dists.gumbel.logcdf,"@stdlib/stats/base/dists/gumbel/logcdf"
+base.dists.gumbel.logpdf,"@stdlib/stats/base/dists/gumbel/logpdf"
+base.dists.gumbel.mean,"@stdlib/stats/base/dists/gumbel/mean"
+base.dists.gumbel.median,"@stdlib/stats/base/dists/gumbel/median"
+base.dists.gumbel.mgf,"@stdlib/stats/base/dists/gumbel/mgf"
+base.dists.gumbel.mode,"@stdlib/stats/base/dists/gumbel/mode"
+base.dists.gumbel.pdf,"@stdlib/stats/base/dists/gumbel/pdf"
+base.dists.gumbel.quantile,"@stdlib/stats/base/dists/gumbel/quantile"
+base.dists.gumbel.skewness,"@stdlib/stats/base/dists/gumbel/skewness"
+base.dists.gumbel.stdev,"@stdlib/stats/base/dists/gumbel/stdev"
+base.dists.gumbel.variance,"@stdlib/stats/base/dists/gumbel/variance"
+base.dists.hypergeometric.cdf,"@stdlib/stats/base/dists/hypergeometric/cdf"
+base.dists.hypergeometric.Hypergeometric,"@stdlib/stats/base/dists/hypergeometric/ctor"
+base.dists.hypergeometric.kurtosis,"@stdlib/stats/base/dists/hypergeometric/kurtosis"
+base.dists.hypergeometric.logpmf,"@stdlib/stats/base/dists/hypergeometric/logpmf"
+base.dists.hypergeometric.mean,"@stdlib/stats/base/dists/hypergeometric/mean"
+base.dists.hypergeometric.mode,"@stdlib/stats/base/dists/hypergeometric/mode"
+base.dists.hypergeometric.pmf,"@stdlib/stats/base/dists/hypergeometric/pmf"
+base.dists.hypergeometric.quantile,"@stdlib/stats/base/dists/hypergeometric/quantile"
+base.dists.hypergeometric.skewness,"@stdlib/stats/base/dists/hypergeometric/skewness"
+base.dists.hypergeometric.stdev,"@stdlib/stats/base/dists/hypergeometric/stdev"
+base.dists.hypergeometric.variance,"@stdlib/stats/base/dists/hypergeometric/variance"
+base.dists.invgamma.cdf,"@stdlib/stats/base/dists/invgamma/cdf"
+base.dists.invgamma.entropy,"@stdlib/stats/base/dists/invgamma/entropy"
+base.dists.invgamma.InvGamma,"@stdlib/stats/base/dists/invgamma/ctor"
+base.dists.invgamma.kurtosis,"@stdlib/stats/base/dists/invgamma/kurtosis"
+base.dists.invgamma.logpdf,"@stdlib/stats/base/dists/invgamma/logpdf"
+base.dists.invgamma.mean,"@stdlib/stats/base/dists/invgamma/mean"
+base.dists.invgamma.mode,"@stdlib/stats/base/dists/invgamma/mode"
+base.dists.invgamma.pdf,"@stdlib/stats/base/dists/invgamma/pdf"
+base.dists.invgamma.quantile,"@stdlib/stats/base/dists/invgamma/quantile"
+base.dists.invgamma.skewness,"@stdlib/stats/base/dists/invgamma/skewness"
+base.dists.invgamma.stdev,"@stdlib/stats/base/dists/invgamma/stdev"
+base.dists.invgamma.variance,"@stdlib/stats/base/dists/invgamma/variance"
+base.dists.kumaraswamy.cdf,"@stdlib/stats/base/dists/kumaraswamy/cdf"
+base.dists.kumaraswamy.Kumaraswamy,"@stdlib/stats/base/dists/kumaraswamy/ctor"
+base.dists.kumaraswamy.kurtosis,"@stdlib/stats/base/dists/kumaraswamy/kurtosis"
+base.dists.kumaraswamy.logcdf,"@stdlib/stats/base/dists/kumaraswamy/logcdf"
+base.dists.kumaraswamy.logpdf,"@stdlib/stats/base/dists/kumaraswamy/logpdf"
+base.dists.kumaraswamy.mean,"@stdlib/stats/base/dists/kumaraswamy/mean"
+base.dists.kumaraswamy.median,"@stdlib/stats/base/dists/kumaraswamy/median"
+base.dists.kumaraswamy.mode,"@stdlib/stats/base/dists/kumaraswamy/mode"
+base.dists.kumaraswamy.pdf,"@stdlib/stats/base/dists/kumaraswamy/pdf"
+base.dists.kumaraswamy.quantile,"@stdlib/stats/base/dists/kumaraswamy/quantile"
+base.dists.kumaraswamy.skewness,"@stdlib/stats/base/dists/kumaraswamy/skewness"
+base.dists.kumaraswamy.stdev,"@stdlib/stats/base/dists/kumaraswamy/stdev"
+base.dists.kumaraswamy.variance,"@stdlib/stats/base/dists/kumaraswamy/variance"
+base.dists.laplace.cdf,"@stdlib/stats/base/dists/laplace/cdf"
+base.dists.laplace.entropy,"@stdlib/stats/base/dists/laplace/entropy"
+base.dists.laplace.kurtosis,"@stdlib/stats/base/dists/laplace/kurtosis"
+base.dists.laplace.Laplace,"@stdlib/stats/base/dists/laplace/ctor"
+base.dists.laplace.logcdf,"@stdlib/stats/base/dists/laplace/logcdf"
+base.dists.laplace.logpdf,"@stdlib/stats/base/dists/laplace/logpdf"
+base.dists.laplace.mean,"@stdlib/stats/base/dists/laplace/mean"
+base.dists.laplace.median,"@stdlib/stats/base/dists/laplace/median"
+base.dists.laplace.mgf,"@stdlib/stats/base/dists/laplace/mgf"
+base.dists.laplace.mode,"@stdlib/stats/base/dists/laplace/mode"
+base.dists.laplace.pdf,"@stdlib/stats/base/dists/laplace/pdf"
+base.dists.laplace.quantile,"@stdlib/stats/base/dists/laplace/quantile"
+base.dists.laplace.skewness,"@stdlib/stats/base/dists/laplace/skewness"
+base.dists.laplace.stdev,"@stdlib/stats/base/dists/laplace/stdev"
+base.dists.laplace.variance,"@stdlib/stats/base/dists/laplace/variance"
+base.dists.levy.cdf,"@stdlib/stats/base/dists/levy/cdf"
+base.dists.levy.entropy,"@stdlib/stats/base/dists/levy/entropy"
+base.dists.levy.Levy,"@stdlib/stats/base/dists/levy/ctor"
+base.dists.levy.logcdf,"@stdlib/stats/base/dists/levy/logcdf"
+base.dists.levy.logpdf,"@stdlib/stats/base/dists/levy/logpdf"
+base.dists.levy.mean,"@stdlib/stats/base/dists/levy/mean"
+base.dists.levy.median,"@stdlib/stats/base/dists/levy/median"
+base.dists.levy.mode,"@stdlib/stats/base/dists/levy/mode"
+base.dists.levy.pdf,"@stdlib/stats/base/dists/levy/pdf"
+base.dists.levy.quantile,"@stdlib/stats/base/dists/levy/quantile"
+base.dists.levy.stdev,"@stdlib/stats/base/dists/levy/stdev"
+base.dists.levy.variance,"@stdlib/stats/base/dists/levy/variance"
+base.dists.logistic.cdf,"@stdlib/stats/base/dists/logistic/cdf"
+base.dists.logistic.entropy,"@stdlib/stats/base/dists/logistic/entropy"
+base.dists.logistic.kurtosis,"@stdlib/stats/base/dists/logistic/kurtosis"
+base.dists.logistic.logcdf,"@stdlib/stats/base/dists/logistic/logcdf"
+base.dists.logistic.Logistic,"@stdlib/stats/base/dists/logistic/ctor"
+base.dists.logistic.logpdf,"@stdlib/stats/base/dists/logistic/logpdf"
+base.dists.logistic.mean,"@stdlib/stats/base/dists/logistic/mean"
+base.dists.logistic.median,"@stdlib/stats/base/dists/logistic/median"
+base.dists.logistic.mgf,"@stdlib/stats/base/dists/logistic/mgf"
+base.dists.logistic.mode,"@stdlib/stats/base/dists/logistic/mode"
+base.dists.logistic.pdf,"@stdlib/stats/base/dists/logistic/pdf"
+base.dists.logistic.quantile,"@stdlib/stats/base/dists/logistic/quantile"
+base.dists.logistic.skewness,"@stdlib/stats/base/dists/logistic/skewness"
+base.dists.logistic.stdev,"@stdlib/stats/base/dists/logistic/stdev"
+base.dists.logistic.variance,"@stdlib/stats/base/dists/logistic/variance"
+base.dists.lognormal.cdf,"@stdlib/stats/base/dists/lognormal/cdf"
+base.dists.lognormal.entropy,"@stdlib/stats/base/dists/lognormal/entropy"
+base.dists.lognormal.kurtosis,"@stdlib/stats/base/dists/lognormal/kurtosis"
+base.dists.lognormal.LogNormal,"@stdlib/stats/base/dists/lognormal/ctor"
+base.dists.lognormal.logpdf,"@stdlib/stats/base/dists/lognormal/logpdf"
+base.dists.lognormal.mean,"@stdlib/stats/base/dists/lognormal/mean"
+base.dists.lognormal.median,"@stdlib/stats/base/dists/lognormal/median"
+base.dists.lognormal.mode,"@stdlib/stats/base/dists/lognormal/mode"
+base.dists.lognormal.pdf,"@stdlib/stats/base/dists/lognormal/pdf"
+base.dists.lognormal.quantile,"@stdlib/stats/base/dists/lognormal/quantile"
+base.dists.lognormal.skewness,"@stdlib/stats/base/dists/lognormal/skewness"
+base.dists.lognormal.stdev,"@stdlib/stats/base/dists/lognormal/stdev"
+base.dists.lognormal.variance,"@stdlib/stats/base/dists/lognormal/variance"
+base.dists.negativeBinomial.cdf,"@stdlib/stats/base/dists/negative-binomial/cdf"
+base.dists.negativeBinomial.kurtosis,"@stdlib/stats/base/dists/negative-binomial/kurtosis"
+base.dists.negativeBinomial.logpmf,"@stdlib/stats/base/dists/negative-binomial/logpmf"
+base.dists.negativeBinomial.mean,"@stdlib/stats/base/dists/negative-binomial/mean"
+base.dists.negativeBinomial.mgf,"@stdlib/stats/base/dists/negative-binomial/mgf"
+base.dists.negativeBinomial.mode,"@stdlib/stats/base/dists/negative-binomial/mode"
+base.dists.negativeBinomial.NegativeBinomial,"@stdlib/stats/base/dists/negative-binomial/ctor"
+base.dists.negativeBinomial.pmf,"@stdlib/stats/base/dists/negative-binomial/pmf"
+base.dists.negativeBinomial.quantile,"@stdlib/stats/base/dists/negative-binomial/quantile"
+base.dists.negativeBinomial.skewness,"@stdlib/stats/base/dists/negative-binomial/skewness"
+base.dists.negativeBinomial.stdev,"@stdlib/stats/base/dists/negative-binomial/stdev"
+base.dists.negativeBinomial.variance,"@stdlib/stats/base/dists/negative-binomial/variance"
+base.dists.normal.cdf,"@stdlib/stats/base/dists/normal/cdf"
+base.dists.normal.entropy,"@stdlib/stats/base/dists/normal/entropy"
+base.dists.normal.kurtosis,"@stdlib/stats/base/dists/normal/kurtosis"
+base.dists.normal.logpdf,"@stdlib/stats/base/dists/normal/logpdf"
+base.dists.normal.mean,"@stdlib/stats/base/dists/normal/mean"
+base.dists.normal.median,"@stdlib/stats/base/dists/normal/median"
+base.dists.normal.mgf,"@stdlib/stats/base/dists/normal/mgf"
+base.dists.normal.mode,"@stdlib/stats/base/dists/normal/mode"
+base.dists.normal.Normal,"@stdlib/stats/base/dists/normal/ctor"
+base.dists.normal.pdf,"@stdlib/stats/base/dists/normal/pdf"
+base.dists.normal.quantile,"@stdlib/stats/base/dists/normal/quantile"
+base.dists.normal.skewness,"@stdlib/stats/base/dists/normal/skewness"
+base.dists.normal.stdev,"@stdlib/stats/base/dists/normal/stdev"
+base.dists.normal.variance,"@stdlib/stats/base/dists/normal/variance"
+base.dists.pareto1.cdf,"@stdlib/stats/base/dists/pareto-type1/cdf"
+base.dists.pareto1.entropy,"@stdlib/stats/base/dists/pareto-type1/entropy"
+base.dists.pareto1.kurtosis,"@stdlib/stats/base/dists/pareto-type1/kurtosis"
+base.dists.pareto1.logcdf,"@stdlib/stats/base/dists/pareto-type1/logcdf"
+base.dists.pareto1.logpdf,"@stdlib/stats/base/dists/pareto-type1/logpdf"
+base.dists.pareto1.mean,"@stdlib/stats/base/dists/pareto-type1/mean"
+base.dists.pareto1.median,"@stdlib/stats/base/dists/pareto-type1/median"
+base.dists.pareto1.mode,"@stdlib/stats/base/dists/pareto-type1/mode"
+base.dists.pareto1.Pareto1,"@stdlib/stats/base/dists/pareto-type1/ctor"
+base.dists.pareto1.pdf,"@stdlib/stats/base/dists/pareto-type1/pdf"
+base.dists.pareto1.quantile,"@stdlib/stats/base/dists/pareto-type1/quantile"
+base.dists.pareto1.skewness,"@stdlib/stats/base/dists/pareto-type1/skewness"
+base.dists.pareto1.variance,"@stdlib/stats/base/dists/pareto-type1/variance"
+base.dists.poisson.cdf,"@stdlib/stats/base/dists/poisson/cdf"
+base.dists.poisson.entropy,"@stdlib/stats/base/dists/poisson/entropy"
+base.dists.poisson.kurtosis,"@stdlib/stats/base/dists/poisson/kurtosis"
+base.dists.poisson.logpmf,"@stdlib/stats/base/dists/poisson/logpmf"
+base.dists.poisson.mean,"@stdlib/stats/base/dists/poisson/mean"
+base.dists.poisson.median,"@stdlib/stats/base/dists/poisson/median"
+base.dists.poisson.mgf,"@stdlib/stats/base/dists/poisson/mgf"
+base.dists.poisson.mode,"@stdlib/stats/base/dists/poisson/mode"
+base.dists.poisson.pmf,"@stdlib/stats/base/dists/poisson/pmf"
+base.dists.poisson.Poisson,"@stdlib/stats/base/dists/poisson/ctor"
+base.dists.poisson.quantile,"@stdlib/stats/base/dists/poisson/quantile"
+base.dists.poisson.skewness,"@stdlib/stats/base/dists/poisson/skewness"
+base.dists.poisson.stdev,"@stdlib/stats/base/dists/poisson/stdev"
+base.dists.poisson.variance,"@stdlib/stats/base/dists/poisson/variance"
+base.dists.rayleigh.cdf,"@stdlib/stats/base/dists/rayleigh/cdf"
+base.dists.rayleigh.entropy,"@stdlib/stats/base/dists/rayleigh/entropy"
+base.dists.rayleigh.kurtosis,"@stdlib/stats/base/dists/rayleigh/kurtosis"
+base.dists.rayleigh.logcdf,"@stdlib/stats/base/dists/rayleigh/logcdf"
+base.dists.rayleigh.logpdf,"@stdlib/stats/base/dists/rayleigh/logpdf"
+base.dists.rayleigh.mean,"@stdlib/stats/base/dists/rayleigh/mean"
+base.dists.rayleigh.median,"@stdlib/stats/base/dists/rayleigh/median"
+base.dists.rayleigh.mgf,"@stdlib/stats/base/dists/rayleigh/mgf"
+base.dists.rayleigh.mode,"@stdlib/stats/base/dists/rayleigh/mode"
+base.dists.rayleigh.pdf,"@stdlib/stats/base/dists/rayleigh/pdf"
+base.dists.rayleigh.quantile,"@stdlib/stats/base/dists/rayleigh/quantile"
+base.dists.rayleigh.Rayleigh,"@stdlib/stats/base/dists/rayleigh/ctor"
+base.dists.rayleigh.skewness,"@stdlib/stats/base/dists/rayleigh/skewness"
+base.dists.rayleigh.stdev,"@stdlib/stats/base/dists/rayleigh/stdev"
+base.dists.rayleigh.variance,"@stdlib/stats/base/dists/rayleigh/variance"
+base.dists.t.cdf,"@stdlib/stats/base/dists/t/cdf"
+base.dists.t.entropy,"@stdlib/stats/base/dists/t/entropy"
+base.dists.t.kurtosis,"@stdlib/stats/base/dists/t/kurtosis"
+base.dists.t.mean,"@stdlib/stats/base/dists/t/mean"
+base.dists.t.median,"@stdlib/stats/base/dists/t/median"
+base.dists.t.mode,"@stdlib/stats/base/dists/t/mode"
+base.dists.t.pdf,"@stdlib/stats/base/dists/t/pdf"
+base.dists.t.quantile,"@stdlib/stats/base/dists/t/quantile"
+base.dists.t.skewness,"@stdlib/stats/base/dists/t/skewness"
+base.dists.t.stdev,"@stdlib/stats/base/dists/t/stdev"
+base.dists.t.T,"@stdlib/stats/base/dists/t/ctor"
+base.dists.t.variance,"@stdlib/stats/base/dists/t/variance"
+base.dists.triangular.cdf,"@stdlib/stats/base/dists/triangular/cdf"
+base.dists.triangular.entropy,"@stdlib/stats/base/dists/triangular/entropy"
+base.dists.triangular.kurtosis,"@stdlib/stats/base/dists/triangular/kurtosis"
+base.dists.triangular.logcdf,"@stdlib/stats/base/dists/triangular/logcdf"
+base.dists.triangular.logpdf,"@stdlib/stats/base/dists/triangular/logpdf"
+base.dists.triangular.mean,"@stdlib/stats/base/dists/triangular/mean"
+base.dists.triangular.median,"@stdlib/stats/base/dists/triangular/median"
+base.dists.triangular.mgf,"@stdlib/stats/base/dists/triangular/mgf"
+base.dists.triangular.mode,"@stdlib/stats/base/dists/triangular/mode"
+base.dists.triangular.pdf,"@stdlib/stats/base/dists/triangular/pdf"
+base.dists.triangular.quantile,"@stdlib/stats/base/dists/triangular/quantile"
+base.dists.triangular.skewness,"@stdlib/stats/base/dists/triangular/skewness"
+base.dists.triangular.stdev,"@stdlib/stats/base/dists/triangular/stdev"
+base.dists.triangular.Triangular,"@stdlib/stats/base/dists/triangular/ctor"
+base.dists.triangular.variance,"@stdlib/stats/base/dists/triangular/variance"
+base.dists.uniform.cdf,"@stdlib/stats/base/dists/uniform/cdf"
+base.dists.uniform.entropy,"@stdlib/stats/base/dists/uniform/entropy"
+base.dists.uniform.kurtosis,"@stdlib/stats/base/dists/uniform/kurtosis"
+base.dists.uniform.logcdf,"@stdlib/stats/base/dists/uniform/logcdf"
+base.dists.uniform.logpdf,"@stdlib/stats/base/dists/uniform/logpdf"
+base.dists.uniform.mean,"@stdlib/stats/base/dists/uniform/mean"
+base.dists.uniform.median,"@stdlib/stats/base/dists/uniform/median"
+base.dists.uniform.mgf,"@stdlib/stats/base/dists/uniform/mgf"
+base.dists.uniform.pdf,"@stdlib/stats/base/dists/uniform/pdf"
+base.dists.uniform.quantile,"@stdlib/stats/base/dists/uniform/quantile"
+base.dists.uniform.skewness,"@stdlib/stats/base/dists/uniform/skewness"
+base.dists.uniform.stdev,"@stdlib/stats/base/dists/uniform/stdev"
+base.dists.uniform.Uniform,"@stdlib/stats/base/dists/uniform/ctor"
+base.dists.uniform.variance,"@stdlib/stats/base/dists/uniform/variance"
+base.dists.weibull.cdf,"@stdlib/stats/base/dists/weibull/cdf"
+base.dists.weibull.entropy,"@stdlib/stats/base/dists/weibull/entropy"
+base.dists.weibull.kurtosis,"@stdlib/stats/base/dists/weibull/kurtosis"
+base.dists.weibull.logcdf,"@stdlib/stats/base/dists/weibull/logcdf"
+base.dists.weibull.logpdf,"@stdlib/stats/base/dists/weibull/logpdf"
+base.dists.weibull.mean,"@stdlib/stats/base/dists/weibull/mean"
+base.dists.weibull.median,"@stdlib/stats/base/dists/weibull/median"
+base.dists.weibull.mgf,"@stdlib/stats/base/dists/weibull/mgf"
+base.dists.weibull.mode,"@stdlib/stats/base/dists/weibull/mode"
+base.dists.weibull.pdf,"@stdlib/stats/base/dists/weibull/pdf"
+base.dists.weibull.quantile,"@stdlib/stats/base/dists/weibull/quantile"
+base.dists.weibull.skewness,"@stdlib/stats/base/dists/weibull/skewness"
+base.dists.weibull.stdev,"@stdlib/stats/base/dists/weibull/stdev"
+base.dists.weibull.variance,"@stdlib/stats/base/dists/weibull/variance"
+base.dists.weibull.Weibull,"@stdlib/stats/base/dists/weibull/ctor"
+base.ellipe,"@stdlib/math/base/special/ellipe"
+base.ellipk,"@stdlib/math/base/special/ellipk"
+base.epsdiff,"@stdlib/math/base/utils/float64-epsilon-difference"
+base.erf,"@stdlib/math/base/special/erf"
+base.erfc,"@stdlib/math/base/special/erfc"
+base.erfcinv,"@stdlib/math/base/special/erfcinv"
+base.erfinv,"@stdlib/math/base/special/erfinv"
+base.eta,"@stdlib/math/base/special/dirichlet-eta"
+base.evalpoly,"@stdlib/math/base/tools/evalpoly"
+base.evalrational,"@stdlib/math/base/tools/evalrational"
+base.exp,"@stdlib/math/base/special/exp"
+base.exp2,"@stdlib/math/base/special/exp2"
+base.exp10,"@stdlib/math/base/special/exp10"
+base.expit,"@stdlib/math/base/special/expit"
+base.expm1,"@stdlib/math/base/special/expm1"
+base.expm1rel,"@stdlib/math/base/special/expm1rel"
+base.exponent,"@stdlib/number/float64/base/exponent"
+base.exponentf,"@stdlib/number/float32/base/exponent"
+base.factorial,"@stdlib/math/base/special/factorial"
+base.factorialln,"@stdlib/math/base/special/factorialln"
+base.fallingFactorial,"@stdlib/math/base/special/falling-factorial"
+base.fibonacci,"@stdlib/math/base/special/fibonacci"
+base.fibonacciIndex,"@stdlib/math/base/special/fibonacci-index"
+base.fibpoly,"@stdlib/math/base/tools/fibpoly"
+base.flipsign,"@stdlib/math/base/special/flipsign"
+base.float32ToInt32,"@stdlib/number/float32/base/to-int32"
+base.float32ToUint32,"@stdlib/number/float32/base/to-uint32"
+base.float64ToFloat32,"@stdlib/number/float64/base/to-float32"
+base.float64ToInt32,"@stdlib/number/float64/base/to-int32"
+base.float64ToUint32,"@stdlib/number/float64/base/to-uint32"
+base.floor,"@stdlib/math/base/special/floor"
+base.floor2,"@stdlib/math/base/special/floor2"
+base.floor10,"@stdlib/math/base/special/floor10"
+base.floorb,"@stdlib/math/base/special/floorb"
+base.floorn,"@stdlib/math/base/special/floorn"
+base.floorsd,"@stdlib/math/base/special/floorsd"
+base.fresnel,"@stdlib/math/base/special/fresnel"
+base.fresnelc,"@stdlib/math/base/special/fresnelc"
+base.fresnels,"@stdlib/math/base/special/fresnels"
+base.frexp,"@stdlib/math/base/special/frexp"
+base.fromBinaryString,"@stdlib/number/float64/base/from-binary-string"
+base.fromBinaryStringf,"@stdlib/number/float32/base/from-binary-string"
+base.fromBinaryStringUint8,"@stdlib/number/uint8/base/from-binary-string"
+base.fromBinaryStringUint16,"@stdlib/number/uint16/base/from-binary-string"
+base.fromBinaryStringUint32,"@stdlib/number/uint32/base/from-binary-string"
+base.fromWordf,"@stdlib/number/float32/base/from-word"
+base.fromWords,"@stdlib/number/float64/base/from-words"
+base.gamma,"@stdlib/math/base/special/gamma"
+base.gamma1pm1,"@stdlib/math/base/special/gamma1pm1"
+base.gammaDeltaRatio,"@stdlib/math/base/special/gamma-delta-ratio"
+base.gammainc,"@stdlib/math/base/special/gammainc"
+base.gammaincinv,"@stdlib/math/base/special/gammaincinv"
+base.gammaLanczosSum,"@stdlib/math/base/special/gamma-lanczos-sum"
+base.gammaLanczosSumExpGScaled,"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled"
+base.gammaln,"@stdlib/math/base/special/gammaln"
+base.gasum,"@stdlib/blas/base/gasum"
+base.gaxpy,"@stdlib/blas/base/gaxpy"
+base.gcd,"@stdlib/math/base/special/gcd"
+base.gcopy,"@stdlib/blas/base/gcopy"
+base.getHighWord,"@stdlib/number/float64/base/get-high-word"
+base.getLowWord,"@stdlib/number/float64/base/get-low-word"
+base.hacovercos,"@stdlib/math/base/special/hacovercos"
+base.hacoversin,"@stdlib/math/base/special/hacoversin"
+base.havercos,"@stdlib/math/base/special/havercos"
+base.haversin,"@stdlib/math/base/special/haversin"
+base.heaviside,"@stdlib/math/base/special/heaviside"
+base.hermitepoly,"@stdlib/math/base/tools/hermitepoly"
+base.hypot,"@stdlib/math/base/special/hypot"
+base.imul,"@stdlib/math/base/special/imul"
+base.imuldw,"@stdlib/math/base/special/imuldw"
+base.int32ToUint32,"@stdlib/number/int32/base/to-uint32"
+base.inv,"@stdlib/math/base/special/inv"
+base.isEven,"@stdlib/math/base/assert/is-even"
+base.isEvenInt32,"@stdlib/math/base/assert/int32-is-even"
+base.isFinite,"@stdlib/math/base/assert/is-finite"
+base.isInfinite,"@stdlib/math/base/assert/is-infinite"
+base.isInteger,"@stdlib/math/base/assert/is-integer"
+base.isnan,"@stdlib/math/base/assert/is-nan"
+base.isNegativeInteger,"@stdlib/math/base/assert/is-negative-integer"
+base.isNegativeZero,"@stdlib/math/base/assert/is-negative-zero"
+base.isNonNegativeInteger,"@stdlib/math/base/assert/is-nonnegative-integer"
+base.isNonPositiveInteger,"@stdlib/math/base/assert/is-nonpositive-integer"
+base.isOdd,"@stdlib/math/base/assert/is-odd"
+base.isOddInt32,"@stdlib/math/base/assert/int32-is-odd"
+base.isPositiveInteger,"@stdlib/math/base/assert/is-positive-integer"
+base.isPositiveZero,"@stdlib/math/base/assert/is-positive-zero"
+base.isPow2Uint32,"@stdlib/math/base/assert/uint32-is-pow2"
+base.isProbability,"@stdlib/math/base/assert/is-probability"
+base.isSafeInteger,"@stdlib/math/base/assert/is-safe-integer"
+base.kernelBetainc,"@stdlib/math/base/special/kernel-betainc"
+base.kernelBetaincinv,"@stdlib/math/base/special/kernel-betaincinv"
+base.kernelCos,"@stdlib/math/base/special/kernel-cos"
+base.kernelSin,"@stdlib/math/base/special/kernel-sin"
+base.kernelTan,"@stdlib/math/base/special/kernel-tan"
+base.kroneckerDelta,"@stdlib/math/base/special/kronecker-delta"
+base.lcm,"@stdlib/math/base/special/lcm"
+base.ldexp,"@stdlib/math/base/special/ldexp"
+base.ln,"@stdlib/math/base/special/ln"
+base.log,"@stdlib/math/base/special/log"
+base.log1mexp,"@stdlib/math/base/special/log1mexp"
+base.log1p,"@stdlib/math/base/special/log1p"
+base.log1pexp,"@stdlib/math/base/special/log1pexp"
+base.log2,"@stdlib/math/base/special/log2"
+base.log10,"@stdlib/math/base/special/log10"
+base.logaddexp,"@stdlib/math/base/special/logaddexp"
+base.logit,"@stdlib/math/base/special/logit"
+base.lucas,"@stdlib/math/base/special/lucas"
+base.lucaspoly,"@stdlib/math/base/tools/lucaspoly"
+base.max,"@stdlib/math/base/special/max"
+base.maxabs,"@stdlib/math/base/special/maxabs"
+base.min,"@stdlib/math/base/special/min"
+base.minabs,"@stdlib/math/base/special/minabs"
+base.minmax,"@stdlib/math/base/special/minmax"
+base.minmaxabs,"@stdlib/math/base/special/minmaxabs"
+base.modf,"@stdlib/math/base/special/modf"
+base.ndarray,"@stdlib/ndarray/base/ctor"
+base.ndarrayMemoized,"@stdlib/ndarray/base/memoized-ctor"
+base.negafibonacci,"@stdlib/math/base/special/negafibonacci"
+base.negalucas,"@stdlib/math/base/special/negalucas"
+base.nonfibonacci,"@stdlib/math/base/special/nonfibonacci"
+base.normalize,"@stdlib/number/float64/base/normalize"
+base.normalizef,"@stdlib/number/float32/base/normalize"
+base.normhermitepoly,"@stdlib/math/base/tools/normhermitepoly"
+base.pdiff,"@stdlib/math/base/special/pdiff"
+base.polygamma,"@stdlib/math/base/special/polygamma"
+base.pow,"@stdlib/math/base/special/pow"
+base.powm1,"@stdlib/math/base/special/powm1"
+base.rad2deg,"@stdlib/math/base/special/rad2deg"
+base.ramp,"@stdlib/math/base/special/ramp"
+base.random.arcsine,"@stdlib/random/base/arcsine"
+base.random.bernoulli,"@stdlib/random/base/bernoulli"
+base.random.beta,"@stdlib/random/base/beta"
+base.random.betaprime,"@stdlib/random/base/betaprime"
+base.random.binomial,"@stdlib/random/base/binomial"
+base.random.boxMuller,"@stdlib/random/base/box-muller"
+base.random.cauchy,"@stdlib/random/base/cauchy"
+base.random.chi,"@stdlib/random/base/chi"
+base.random.chisquare,"@stdlib/random/base/chisquare"
+base.random.cosine,"@stdlib/random/base/cosine"
+base.random.discreteUniform,"@stdlib/random/base/discrete-uniform"
+base.random.erlang,"@stdlib/random/base/erlang"
+base.random.exponential,"@stdlib/random/base/exponential"
+base.random.f,"@stdlib/random/base/f"
+base.random.frechet,"@stdlib/random/base/frechet"
+base.random.gamma,"@stdlib/random/base/gamma"
+base.random.geometric,"@stdlib/random/base/geometric"
+base.random.gumbel,"@stdlib/random/base/gumbel"
+base.random.hypergeometric,"@stdlib/random/base/hypergeometric"
+base.random.improvedZiggurat,"@stdlib/random/base/improved-ziggurat"
+base.random.invgamma,"@stdlib/random/base/invgamma"
+base.random.kumaraswamy,"@stdlib/random/base/kumaraswamy"
+base.random.laplace,"@stdlib/random/base/laplace"
+base.random.levy,"@stdlib/random/base/levy"
+base.random.logistic,"@stdlib/random/base/logistic"
+base.random.lognormal,"@stdlib/random/base/lognormal"
+base.random.minstd,"@stdlib/random/base/minstd"
+base.random.minstdShuffle,"@stdlib/random/base/minstd-shuffle"
+base.random.mt19937,"@stdlib/random/base/mt19937"
+base.random.negativeBinomial,"@stdlib/random/base/negative-binomial"
+base.random.normal,"@stdlib/random/base/normal"
+base.random.pareto1,"@stdlib/random/base/pareto-type1"
+base.random.poisson,"@stdlib/random/base/poisson"
+base.random.randi,"@stdlib/random/base/randi"
+base.random.randn,"@stdlib/random/base/randn"
+base.random.randu,"@stdlib/random/base/randu"
+base.random.rayleigh,"@stdlib/random/base/rayleigh"
+base.random.t,"@stdlib/random/base/t"
+base.random.triangular,"@stdlib/random/base/triangular"
+base.random.uniform,"@stdlib/random/base/uniform"
+base.random.weibull,"@stdlib/random/base/weibull"
+base.reldiff,"@stdlib/math/base/utils/relative-difference"
+base.rempio2,"@stdlib/math/base/special/rempio2"
+base.risingFactorial,"@stdlib/math/base/special/rising-factorial"
+base.rotl32,"@stdlib/number/uint32/base/rotl"
+base.rotr32,"@stdlib/number/uint32/base/rotr"
+base.round,"@stdlib/math/base/special/round"
+base.round2,"@stdlib/math/base/special/round2"
+base.round10,"@stdlib/math/base/special/round10"
+base.roundb,"@stdlib/math/base/special/roundb"
+base.roundn,"@stdlib/math/base/special/roundn"
+base.roundsd,"@stdlib/math/base/special/roundsd"
+base.rsqrt,"@stdlib/math/base/special/rsqrt"
+base.sasum,"@stdlib/blas/base/sasum"
+base.saxpy,"@stdlib/blas/base/saxpy"
+base.scopy,"@stdlib/blas/base/scopy"
+base.setHighWord,"@stdlib/number/float64/base/set-high-word"
+base.setLowWord,"@stdlib/number/float64/base/set-low-word"
+base.sici,"@stdlib/math/base/special/sici"
+base.signbit,"@stdlib/number/float64/base/signbit"
+base.signbitf,"@stdlib/number/float32/base/signbit"
+base.significandf,"@stdlib/number/float32/base/significand"
+base.signum,"@stdlib/math/base/special/signum"
+base.sin,"@stdlib/math/base/special/sin"
+base.sinc,"@stdlib/math/base/special/sinc"
+base.sincos,"@stdlib/math/base/special/sincos"
+base.sincospi,"@stdlib/math/base/special/sincospi"
+base.sinh,"@stdlib/math/base/special/sinh"
+base.sinpi,"@stdlib/math/base/special/sinpi"
+base.spence,"@stdlib/math/base/special/spence"
+base.sqrt,"@stdlib/math/base/special/sqrt"
+base.sqrt1pm1,"@stdlib/math/base/special/sqrt1pm1"
+base.sumSeries,"@stdlib/math/base/tools/sum-series"
+base.tan,"@stdlib/math/base/special/tan"
+base.tanh,"@stdlib/math/base/special/tanh"
+base.toBinaryString,"@stdlib/number/float64/base/to-binary-string"
+base.toBinaryStringf,"@stdlib/number/float32/base/to-binary-string"
+base.toBinaryStringUint8,"@stdlib/number/uint8/base/to-binary-string"
+base.toBinaryStringUint16,"@stdlib/number/uint16/base/to-binary-string"
+base.toBinaryStringUint32,"@stdlib/number/uint32/base/to-binary-string"
+base.toWordf,"@stdlib/number/float32/base/to-word"
+base.toWords,"@stdlib/number/float64/base/to-words"
+base.trigamma,"@stdlib/math/base/special/trigamma"
+base.trunc,"@stdlib/math/base/special/trunc"
+base.trunc2,"@stdlib/math/base/special/trunc2"
+base.trunc10,"@stdlib/math/base/special/trunc10"
+base.truncb,"@stdlib/math/base/special/truncb"
+base.truncn,"@stdlib/math/base/special/truncn"
+base.truncsd,"@stdlib/math/base/special/truncsd"
+base.uimul,"@stdlib/math/base/special/uimul"
+base.uimuldw,"@stdlib/math/base/special/uimuldw"
+base.uint32ToInt32,"@stdlib/number/uint32/base/to-int32"
+base.vercos,"@stdlib/math/base/special/vercos"
+base.versin,"@stdlib/math/base/special/versin"
+base.wrap,"@stdlib/math/base/special/wrap"
+base.xlog1py,"@stdlib/math/base/special/xlog1py"
+base.xlogy,"@stdlib/math/base/special/xlogy"
+base.zeta,"@stdlib/math/base/special/riemann-zeta"
+BERNDT_CPS_WAGES_1985,"@stdlib/datasets/berndt-cps-wages-1985"
+bifurcate,"@stdlib/utils/bifurcate"
+bifurcateBy,"@stdlib/utils/bifurcate-by"
+bifurcateByAsync,"@stdlib/utils/async/bifurcate-by"
+bifurcateIn,"@stdlib/utils/bifurcate-in"
+bifurcateOwn,"@stdlib/utils/bifurcate-own"
+binomialTest,"@stdlib/stats/binomial-test"
+Buffer,"@stdlib/buffer/ctor"
+buffer2json,"@stdlib/buffer/to-json"
+capitalize,"@stdlib/string/capitalize"
+capitalizeKeys,"@stdlib/utils/capitalize-keys"
+CATALAN,"@stdlib/constants/math/float64-catalan"
+CBRT_EPS,"@stdlib/constants/math/float64-cbrt-eps"
+chdir,"@stdlib/process/chdir"
+chi2gof,"@stdlib/stats/chi2gof"
+circarray2iterator,"@stdlib/array/to-circular-iterator"
+circularArrayStream,"@stdlib/streams/node/from-circular-array"
+CircularBuffer,"@stdlib/utils/circular-buffer"
+CMUDICT,"@stdlib/datasets/cmudict"
+complex,"@stdlib/complex/cmplx"
+Complex64,"@stdlib/complex/float32"
+COMPLEX64_NUM_BYTES,"@stdlib/constants/math/complex64-num-bytes"
+Complex64Array,"@stdlib/array/complex64"
+Complex128,"@stdlib/complex/float64"
+COMPLEX128_NUM_BYTES,"@stdlib/constants/math/complex128-num-bytes"
+Complex128Array,"@stdlib/array/complex128"
+compose,"@stdlib/utils/compose"
+composeAsync,"@stdlib/utils/async/compose"
+configdir,"@stdlib/os/configdir"
+conj,"@stdlib/complex/conj"
+constantFunction,"@stdlib/utils/constant-function"
+constantStream,"@stdlib/streams/node/from-constant"
+constructorName,"@stdlib/utils/constructor-name"
+contains,"@stdlib/assert/contains"
+convertArray,"@stdlib/array/convert"
+convertArraySame,"@stdlib/array/convert-same"
+convertPath,"@stdlib/utils/convert-path"
+copy,"@stdlib/utils/copy"
+copyBuffer,"@stdlib/buffer/from-buffer"
+countBy,"@stdlib/utils/count-by"
+countByAsync,"@stdlib/utils/async/count-by"
+curry,"@stdlib/utils/curry"
+curryRight,"@stdlib/utils/curry-right"
+cwd,"@stdlib/process/cwd"
+DALE_CHALL_NEW,"@stdlib/datasets/dale-chall-new"
+datasets,"@stdlib/datasets"
+dayOfQuarter,"@stdlib/time/day-of-quarter"
+dayOfYear,"@stdlib/time/day-of-year"
+daysInMonth,"@stdlib/time/days-in-month"
+daysInYear,"@stdlib/time/days-in-year"
+debugSinkStream,"@stdlib/streams/node/debug-sink"
+debugStream,"@stdlib/streams/node/debug"
+deepEqual,"@stdlib/assert/deep-equal"
+deepGet,"@stdlib/utils/deep-get"
+deepHasOwnProp,"@stdlib/assert/deep-has-own-property"
+deepHasProp,"@stdlib/assert/deep-has-property"
+deepPluck,"@stdlib/utils/deep-pluck"
+deepSet,"@stdlib/utils/deep-set"
+defineMemoizedProperty,"@stdlib/utils/define-memoized-property"
+defineProperties,"@stdlib/utils/define-properties"
+defineProperty,"@stdlib/utils/define-property"
+dirname,"@stdlib/utils/dirname"
+DoublyLinkedList,"@stdlib/utils/doubly-linked-list"
+doUntil,"@stdlib/utils/do-until"
+doUntilAsync,"@stdlib/utils/async/do-until"
+doUntilEach,"@stdlib/utils/do-until-each"
+doUntilEachRight,"@stdlib/utils/do-until-each-right"
+doWhile,"@stdlib/utils/do-while"
+doWhileAsync,"@stdlib/utils/async/do-while"
+doWhileEach,"@stdlib/utils/do-while-each"
+doWhileEachRight,"@stdlib/utils/do-while-each-right"
+E,"@stdlib/constants/math/float64-e"
+emptyStream,"@stdlib/streams/node/empty"
+endsWith,"@stdlib/string/ends-with"
+enumerableProperties,"@stdlib/utils/enumerable-properties"
+enumerablePropertiesIn,"@stdlib/utils/enumerable-properties-in"
+enumerablePropertySymbols,"@stdlib/utils/enumerable-property-symbols"
+enumerablePropertySymbolsIn,"@stdlib/utils/enumerable-property-symbols-in"
+ENV,"@stdlib/process/env"
+EPS,"@stdlib/constants/math/float64-eps"
+error2json,"@stdlib/error/to-json"
+EULERGAMMA,"@stdlib/constants/math/float64-eulergamma"
+every,"@stdlib/utils/every"
+everyBy,"@stdlib/utils/every-by"
+everyByAsync,"@stdlib/utils/async/every-by"
+everyByRight,"@stdlib/utils/every-by-right"
+everyByRightAsync,"@stdlib/utils/async/every-by-right"
+evil,"@stdlib/utils/eval"
+exists,"@stdlib/fs/exists"
+expandContractions,"@stdlib/nlp/expand-contractions"
+extname,"@stdlib/utils/extname"
+fastmath.abs,"@stdlib/fastmath/special/abs"
+fastmath.acosh,"@stdlib/fastmath/special/acosh"
+fastmath.ampbm,"@stdlib/fastmath/special/alpha-max-plus-beta-min"
+fastmath.asinh,"@stdlib/fastmath/special/asinh"
+fastmath.atanh,"@stdlib/fastmath/special/atanh"
+fastmath.hypot,"@stdlib/fastmath/special/hypot"
+fastmath.log2Uint32,"@stdlib/fastmath/special/uint32-log2"
+fastmath.max,"@stdlib/fastmath/special/max"
+fastmath.min,"@stdlib/fastmath/special/min"
+fastmath.powint,"@stdlib/fastmath/special/pow-int"
+fastmath.sqrtUint32,"@stdlib/fastmath/special/uint32-sqrt"
+FEMALE_FIRST_NAMES_EN,"@stdlib/datasets/female-first-names-en"
+FIFO,"@stdlib/utils/fifo"
+find,"@stdlib/utils/find"
+flattenArray,"@stdlib/utils/flatten-array"
+flattenObject,"@stdlib/utils/flatten-object"
+flignerTest,"@stdlib/stats/fligner-test"
+FLOAT16_CBRT_EPS,"@stdlib/constants/math/float16-cbrt-eps"
+FLOAT16_EPS,"@stdlib/constants/math/float16-eps"
+FLOAT16_EXPONENT_BIAS,"@stdlib/constants/math/float16-exponent-bias"
+FLOAT16_MAX,"@stdlib/constants/math/float16-max"
+FLOAT16_MAX_SAFE_INTEGER,"@stdlib/constants/math/float16-max-safe-integer"
+FLOAT16_MIN_SAFE_INTEGER,"@stdlib/constants/math/float16-min-safe-integer"
+FLOAT16_NINF,"@stdlib/constants/math/float16-ninf"
+FLOAT16_NUM_BYTES,"@stdlib/constants/math/float16-num-bytes"
+FLOAT16_PINF,"@stdlib/constants/math/float16-pinf"
+FLOAT16_PRECISION,"@stdlib/constants/math/float16-precision"
+FLOAT16_SMALLEST_NORMAL,"@stdlib/constants/math/float16-smallest-normal"
+FLOAT16_SMALLEST_SUBNORMAL,"@stdlib/constants/math/float16-smallest-subnormal"
+FLOAT16_SQRT_EPS,"@stdlib/constants/math/float16-sqrt-eps"
+FLOAT32_CBRT_EPS,"@stdlib/constants/math/float32-cbrt-eps"
+FLOAT32_EPS,"@stdlib/constants/math/float32-eps"
+FLOAT32_EXPONENT_BIAS,"@stdlib/constants/math/float32-exponent-bias"
+FLOAT32_MAX,"@stdlib/constants/math/float32-max"
+FLOAT32_MAX_SAFE_INTEGER,"@stdlib/constants/math/float32-max-safe-integer"
+FLOAT32_MIN_SAFE_INTEGER,"@stdlib/constants/math/float32-min-safe-integer"
+FLOAT32_NINF,"@stdlib/constants/math/float32-ninf"
+FLOAT32_NUM_BYTES,"@stdlib/constants/math/float32-num-bytes"
+FLOAT32_PINF,"@stdlib/constants/math/float32-pinf"
+FLOAT32_PRECISION,"@stdlib/constants/math/float32-precision"
+FLOAT32_SMALLEST_NORMAL,"@stdlib/constants/math/float32-smallest-normal"
+FLOAT32_SMALLEST_SUBNORMAL,"@stdlib/constants/math/float32-smallest-subnormal"
+FLOAT32_SQRT_EPS,"@stdlib/constants/math/float32-sqrt-eps"
+Float32Array,"@stdlib/array/float32"
+FLOAT64_EXPONENT_BIAS,"@stdlib/constants/math/float64-exponent-bias"
+FLOAT64_HIGH_WORD_EXPONENT_MASK,"@stdlib/constants/math/float64-high-word-exponent-mask"
+FLOAT64_HIGH_WORD_SIGNIFICAND_MASK,"@stdlib/constants/math/float64-high-word-significand-mask"
+FLOAT64_MAX,"@stdlib/constants/math/float64-max"
+FLOAT64_MAX_BASE2_EXPONENT,"@stdlib/constants/math/float64-max-base2-exponent"
+FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,"@stdlib/constants/math/float64-max-base2-exponent-subnormal"
+FLOAT64_MAX_BASE10_EXPONENT,"@stdlib/constants/math/float64-max-base10-exponent"
+FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,"@stdlib/constants/math/float64-max-base10-exponent-subnormal"
+FLOAT64_MAX_LN,"@stdlib/constants/math/float64-max-ln"
+FLOAT64_MAX_SAFE_FIBONACCI,"@stdlib/constants/math/float64-max-safe-fibonacci"
+FLOAT64_MAX_SAFE_INTEGER,"@stdlib/constants/math/float64-max-safe-integer"
+FLOAT64_MAX_SAFE_LUCAS,"@stdlib/constants/math/float64-max-safe-lucas"
+FLOAT64_MAX_SAFE_NTH_FIBONACCI,"@stdlib/constants/math/float64-max-safe-nth-fibonacci"
+FLOAT64_MAX_SAFE_NTH_LUCAS,"@stdlib/constants/math/float64-max-safe-nth-lucas"
+FLOAT64_MIN_BASE2_EXPONENT,"@stdlib/constants/math/float64-min-base2-exponent"
+FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL,"@stdlib/constants/math/float64-min-base2-exponent-subnormal"
+FLOAT64_MIN_BASE10_EXPONENT,"@stdlib/constants/math/float64-min-base10-exponent"
+FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,"@stdlib/constants/math/float64-min-base10-exponent-subnormal"
+FLOAT64_MIN_LN,"@stdlib/constants/math/float64-min-ln"
+FLOAT64_MIN_SAFE_INTEGER,"@stdlib/constants/math/float64-min-safe-integer"
+FLOAT64_NUM_BYTES,"@stdlib/constants/math/float64-num-bytes"
+FLOAT64_PRECISION,"@stdlib/constants/math/float64-precision"
+FLOAT64_SMALLEST_NORMAL,"@stdlib/constants/math/float64-smallest-normal"
+FLOAT64_SMALLEST_SUBNORMAL,"@stdlib/constants/math/float64-smallest-subnormal"
+Float64Array,"@stdlib/array/float64"
+forEach,"@stdlib/utils/for-each"
+forEachAsync,"@stdlib/utils/async/for-each"
+forEachRight,"@stdlib/utils/for-each-right"
+forEachRightAsync,"@stdlib/utils/async/for-each-right"
+forIn,"@stdlib/utils/for-in"
+forOwn,"@stdlib/utils/for-own"
+FOURTH_PI,"@stdlib/constants/math/float64-fourth-pi"
+FOURTH_ROOT_EPS,"@stdlib/constants/math/float64-fourth-root-eps"
+FRB_SF_WAGE_RIGIDITY,"@stdlib/datasets/frb-sf-wage-rigidity"
+fromCodePoint,"@stdlib/string/from-code-point"
+functionName,"@stdlib/utils/function-name"
+functionSequence,"@stdlib/utils/function-sequence"
+functionSequenceAsync,"@stdlib/utils/async/function-sequence"
+GAMMA_LANCZOS_G,"@stdlib/constants/math/float64-gamma-lanczos-g"
+getegid,"@stdlib/process/getegid"
+geteuid,"@stdlib/process/geteuid"
+getgid,"@stdlib/process/getgid"
+getGlobal,"@stdlib/utils/global"
+getPrototypeOf,"@stdlib/utils/get-prototype-of"
+getuid,"@stdlib/process/getuid"
+GLAISHER,"@stdlib/constants/math/float64-glaisher-kinkelin"
+group,"@stdlib/utils/group"
+groupBy,"@stdlib/utils/group-by"
+groupByAsync,"@stdlib/utils/async/group-by"
+groupIn,"@stdlib/utils/group-in"
+groupOwn,"@stdlib/utils/group-own"
+HALF_LN2,"@stdlib/constants/math/float64-half-ln-two"
+HALF_PI,"@stdlib/constants/math/float64-half-pi"
+HARRISON_BOSTON_HOUSE_PRICES,"@stdlib/datasets/harrison-boston-house-prices"
+HARRISON_BOSTON_HOUSE_PRICES_CORRECTED,"@stdlib/datasets/harrison-boston-house-prices-corrected"
+hasArrayBufferSupport,"@stdlib/assert/has-arraybuffer-support"
+hasAsyncAwaitSupport,"@stdlib/assert/has-async-await-support"
+hasAsyncIteratorSymbolSupport,"@stdlib/assert/has-async-iterator-symbol-support"
+hasClassSupport,"@stdlib/assert/has-class-support"
+hasDefinePropertiesSupport,"@stdlib/assert/has-define-properties-support"
+hasDefinePropertySupport,"@stdlib/assert/has-define-property-support"
+hasFloat32ArraySupport,"@stdlib/assert/has-float32array-support"
+hasFloat64ArraySupport,"@stdlib/assert/has-float64array-support"
+hasFunctionNameSupport,"@stdlib/assert/has-function-name-support"
+hasGeneratorSupport,"@stdlib/assert/has-generator-support"
+hasInt8ArraySupport,"@stdlib/assert/has-int8array-support"
+hasInt16ArraySupport,"@stdlib/assert/has-int16array-support"
+hasInt32ArraySupport,"@stdlib/assert/has-int32array-support"
+hasIteratorSymbolSupport,"@stdlib/assert/has-iterator-symbol-support"
+hasMapSupport,"@stdlib/assert/has-map-support"
+hasNodeBufferSupport,"@stdlib/assert/has-node-buffer-support"
+hasOwnProp,"@stdlib/assert/has-own-property"
+hasProp,"@stdlib/assert/has-property"
+hasProxySupport,"@stdlib/assert/has-proxy-support"
+hasSetSupport,"@stdlib/assert/has-set-support"
+hasSharedArrayBufferSupport,"@stdlib/assert/has-sharedarraybuffer-support"
+hasSymbolSupport,"@stdlib/assert/has-symbol-support"
+hasToStringTagSupport,"@stdlib/assert/has-tostringtag-support"
+hasUint8ArraySupport,"@stdlib/assert/has-uint8array-support"
+hasUint8ClampedArraySupport,"@stdlib/assert/has-uint8clampedarray-support"
+hasUint16ArraySupport,"@stdlib/assert/has-uint16array-support"
+hasUint32ArraySupport,"@stdlib/assert/has-uint32array-support"
+hasWeakMapSupport,"@stdlib/assert/has-weakmap-support"
+hasWeakSetSupport,"@stdlib/assert/has-weakset-support"
+hasWebAssemblySupport,"@stdlib/assert/has-wasm-support"
+HERNDON_VENUS_SEMIDIAMETERS,"@stdlib/datasets/herndon-venus-semidiameters"
+homedir,"@stdlib/os/homedir"
+HOURS_IN_DAY,"@stdlib/constants/time/hours-in-day"
+HOURS_IN_WEEK,"@stdlib/constants/time/hours-in-week"
+hoursInMonth,"@stdlib/time/hours-in-month"
+hoursInYear,"@stdlib/time/hours-in-year"
+httpServer,"@stdlib/net/http-server"
+identity,"@stdlib/utils/identity-function"
+ifelse,"@stdlib/utils/if-else"
+ifelseAsync,"@stdlib/utils/async/if-else"
+ifthen,"@stdlib/utils/if-then"
+ifthenAsync,"@stdlib/utils/async/if-then"
+imag,"@stdlib/complex/imag"
+IMG_ACANTHUS_MOLLIS,"@stdlib/datasets/img-acanthus-mollis"
+IMG_AIRPLANE_FROM_ABOVE,"@stdlib/datasets/img-airplane-from-above"
+IMG_ALLIUM_OREOPHILUM,"@stdlib/datasets/img-allium-oreophilum"
+IMG_BLACK_CANYON,"@stdlib/datasets/img-black-canyon"
+IMG_DUST_BOWL_HOME,"@stdlib/datasets/img-dust-bowl-home"
+IMG_FRENCH_ALPINE_LANDSCAPE,"@stdlib/datasets/img-french-alpine-landscape"
+IMG_LOCOMOTION_HOUSE_CAT,"@stdlib/datasets/img-locomotion-house-cat"
+IMG_LOCOMOTION_NUDE_MALE,"@stdlib/datasets/img-locomotion-nude-male"
+IMG_MARCH_PASTORAL,"@stdlib/datasets/img-march-pastoral"
+IMG_NAGASAKI_BOATS,"@stdlib/datasets/img-nagasaki-boats"
+incrapcorr,"@stdlib/stats/incr/apcorr"
+incrcount,"@stdlib/stats/incr/count"
+incrcovariance,"@stdlib/stats/incr/covariance"
+incrcovmat,"@stdlib/stats/incr/covmat"
+incrcv,"@stdlib/stats/incr/cv"
+increwmean,"@stdlib/stats/incr/ewmean"
+increwstdev,"@stdlib/stats/incr/ewstdev"
+increwvariance,"@stdlib/stats/incr/ewvariance"
+incrgmean,"@stdlib/stats/incr/gmean"
+incrgrubbs,"@stdlib/stats/incr/grubbs"
+incrhmean,"@stdlib/stats/incr/hmean"
+incrkmeans,"@stdlib/ml/incr/kmeans"
+incrkurtosis,"@stdlib/stats/incr/kurtosis"
+incrmaape,"@stdlib/stats/incr/maape"
+incrmae,"@stdlib/stats/incr/mae"
+incrmapcorr,"@stdlib/stats/incr/mapcorr"
+incrmape,"@stdlib/stats/incr/mape"
+incrmax,"@stdlib/stats/incr/max"
+incrmaxabs,"@stdlib/stats/incr/maxabs"
+incrmcovariance,"@stdlib/stats/incr/mcovariance"
+incrmcv,"@stdlib/stats/incr/mcv"
+incrmda,"@stdlib/stats/incr/mda"
+incrme,"@stdlib/stats/incr/me"
+incrmean,"@stdlib/stats/incr/mean"
+incrmeanabs,"@stdlib/stats/incr/meanabs"
+incrmeanabs2,"@stdlib/stats/incr/meanabs2"
+incrmeanstdev,"@stdlib/stats/incr/meanstdev"
+incrmeanvar,"@stdlib/stats/incr/meanvar"
+incrmgmean,"@stdlib/stats/incr/mgmean"
+incrmgrubbs,"@stdlib/stats/incr/mgrubbs"
+incrmhmean,"@stdlib/stats/incr/mhmean"
+incrmidrange,"@stdlib/stats/incr/midrange"
+incrmin,"@stdlib/stats/incr/min"
+incrminabs,"@stdlib/stats/incr/minabs"
+incrminmax,"@stdlib/stats/incr/minmax"
+incrminmaxabs,"@stdlib/stats/incr/minmaxabs"
+incrmmaape,"@stdlib/stats/incr/mmaape"
+incrmmae,"@stdlib/stats/incr/mmae"
+incrmmape,"@stdlib/stats/incr/mmape"
+incrmmax,"@stdlib/stats/incr/mmax"
+incrmmaxabs,"@stdlib/stats/incr/mmaxabs"
+incrmmda,"@stdlib/stats/incr/mmda"
+incrmme,"@stdlib/stats/incr/mme"
+incrmmean,"@stdlib/stats/incr/mmean"
+incrmmeanabs,"@stdlib/stats/incr/mmeanabs"
+incrmmeanabs2,"@stdlib/stats/incr/mmeanabs2"
+incrmmeanstdev,"@stdlib/stats/incr/mmeanstdev"
+incrmmeanvar,"@stdlib/stats/incr/mmeanvar"
+incrmmidrange,"@stdlib/stats/incr/mmidrange"
+incrmmin,"@stdlib/stats/incr/mmin"
+incrmminabs,"@stdlib/stats/incr/mminabs"
+incrmminmax,"@stdlib/stats/incr/mminmax"
+incrmminmaxabs,"@stdlib/stats/incr/mminmaxabs"
+incrmmpe,"@stdlib/stats/incr/mmpe"
+incrmmse,"@stdlib/stats/incr/mmse"
+incrmpcorr,"@stdlib/stats/incr/mpcorr"
+incrmpcorr2,"@stdlib/stats/incr/mpcorr2"
+incrmpcorrdist,"@stdlib/stats/incr/mpcorrdist"
+incrmpe,"@stdlib/stats/incr/mpe"
+incrmprod,"@stdlib/stats/incr/mprod"
+incrmrange,"@stdlib/stats/incr/mrange"
+incrmrmse,"@stdlib/stats/incr/mrmse"
+incrmrss,"@stdlib/stats/incr/mrss"
+incrmse,"@stdlib/stats/incr/mse"
+incrmstdev,"@stdlib/stats/incr/mstdev"
+incrmsum,"@stdlib/stats/incr/msum"
+incrmsumabs,"@stdlib/stats/incr/msumabs"
+incrmsumabs2,"@stdlib/stats/incr/msumabs2"
+incrmsummary,"@stdlib/stats/incr/msummary"
+incrmsumprod,"@stdlib/stats/incr/msumprod"
+incrmvariance,"@stdlib/stats/incr/mvariance"
+incrmvmr,"@stdlib/stats/incr/mvmr"
+incrpcorr,"@stdlib/stats/incr/pcorr"
+incrpcorr2,"@stdlib/stats/incr/pcorr2"
+incrpcorrdist,"@stdlib/stats/incr/pcorrdist"
+incrpcorrdistmat,"@stdlib/stats/incr/pcorrdistmat"
+incrpcorrmat,"@stdlib/stats/incr/pcorrmat"
+incrprod,"@stdlib/stats/incr/prod"
+incrrange,"@stdlib/stats/incr/range"
+incrrmse,"@stdlib/stats/incr/rmse"
+incrrss,"@stdlib/stats/incr/rss"
+incrskewness,"@stdlib/stats/incr/skewness"
+incrspace,"@stdlib/math/utils/incrspace"
+incrstdev,"@stdlib/stats/incr/stdev"
+incrsum,"@stdlib/stats/incr/sum"
+incrsumabs,"@stdlib/stats/incr/sumabs"
+incrsumabs2,"@stdlib/stats/incr/sumabs2"
+incrsummary,"@stdlib/stats/incr/summary"
+incrsumprod,"@stdlib/stats/incr/sumprod"
+incrvariance,"@stdlib/stats/incr/variance"
+incrvmr,"@stdlib/stats/incr/vmr"
+incrwmean,"@stdlib/stats/incr/wmean"
+ind2sub,"@stdlib/ndarray/ind2sub"
+indexOf,"@stdlib/utils/index-of"
+inherit,"@stdlib/utils/inherit"
+inheritedEnumerableProperties,"@stdlib/utils/inherited-enumerable-properties"
+inheritedEnumerablePropertySymbols,"@stdlib/utils/inherited-enumerable-property-symbols"
+inheritedKeys,"@stdlib/utils/inherited-keys"
+inheritedNonEnumerableProperties,"@stdlib/utils/inherited-nonenumerable-properties"
+inheritedNonEnumerablePropertyNames,"@stdlib/utils/inherited-nonenumerable-property-names"
+inheritedNonEnumerablePropertySymbols,"@stdlib/utils/inherited-nonenumerable-property-symbols"
+inheritedProperties,"@stdlib/utils/inherited-properties"
+inheritedPropertyDescriptor,"@stdlib/utils/inherited-property-descriptor"
+inheritedPropertyDescriptors,"@stdlib/utils/inherited-property-descriptors"
+inheritedPropertyNames,"@stdlib/utils/inherited-property-names"
+inheritedPropertySymbols,"@stdlib/utils/inherited-property-symbols"
+inheritedWritableProperties,"@stdlib/utils/inherited-writable-properties"
+inheritedWritablePropertyNames,"@stdlib/utils/inherited-writable-property-names"
+inheritedWritablePropertySymbols,"@stdlib/utils/inherited-writable-property-symbols"
+inmap,"@stdlib/utils/inmap"
+inmapAsync,"@stdlib/utils/async/inmap"
+inmapRight,"@stdlib/utils/inmap-right"
+inmapRightAsync,"@stdlib/utils/async/inmap-right"
+inspectSinkStream,"@stdlib/streams/node/inspect-sink"
+inspectStream,"@stdlib/streams/node/inspect"
+instanceOf,"@stdlib/assert/instance-of"
+INT8_MAX,"@stdlib/constants/math/int8-max"
+INT8_MIN,"@stdlib/constants/math/int8-min"
+INT8_NUM_BYTES,"@stdlib/constants/math/int8-num-bytes"
+Int8Array,"@stdlib/array/int8"
+INT16_MAX,"@stdlib/constants/math/int16-max"
+INT16_MIN,"@stdlib/constants/math/int16-min"
+INT16_NUM_BYTES,"@stdlib/constants/math/int16-num-bytes"
+Int16Array,"@stdlib/array/int16"
+INT32_MAX,"@stdlib/constants/math/int32-max"
+INT32_MIN,"@stdlib/constants/math/int32-min"
+INT32_NUM_BYTES,"@stdlib/constants/math/int32-num-bytes"
+Int32Array,"@stdlib/array/int32"
+IS_BIG_ENDIAN,"@stdlib/assert/is-big-endian"
+IS_BROWSER,"@stdlib/assert/is-browser"
+IS_DARWIN,"@stdlib/assert/is-darwin"
+IS_ELECTRON,"@stdlib/assert/is-electron"
+IS_ELECTRON_MAIN,"@stdlib/assert/is-electron-main"
+IS_ELECTRON_RENDERER,"@stdlib/assert/is-electron-renderer"
+IS_LITTLE_ENDIAN,"@stdlib/assert/is-little-endian"
+IS_NODE,"@stdlib/assert/is-node"
+IS_WEB_WORKER,"@stdlib/assert/is-web-worker"
+IS_WINDOWS,"@stdlib/assert/is-windows"
+isAbsolutePath,"@stdlib/assert/is-absolute-path"
+isAccessorProperty,"@stdlib/assert/is-accessor-property"
+isAccessorPropertyIn,"@stdlib/assert/is-accessor-property-in"
+isAlphagram,"@stdlib/assert/is-alphagram"
+isAlphaNumeric,"@stdlib/assert/is-alphanumeric"
+isAnagram,"@stdlib/assert/is-anagram"
+isArguments,"@stdlib/assert/is-arguments"
+isArray,"@stdlib/assert/is-array"
+isArrayArray,"@stdlib/assert/is-array-array"
+isArrayBuffer,"@stdlib/assert/is-arraybuffer"
+isArrayLength,"@stdlib/assert/is-array-length"
+isArrayLike,"@stdlib/assert/is-array-like"
+isArrayLikeObject,"@stdlib/assert/is-array-like-object"
+isASCII,"@stdlib/assert/is-ascii"
+isBetween,"@stdlib/assert/is-between"
+isBetweenArray,"@stdlib/assert/is-between-array"
+isBinaryString,"@stdlib/assert/is-binary-string"
+isBoolean,"@stdlib/assert/is-boolean"
+isBooleanArray,"@stdlib/assert/is-boolean-array"
+isBoxedPrimitive,"@stdlib/assert/is-boxed-primitive"
+isBuffer,"@stdlib/assert/is-buffer"
+isCapitalized,"@stdlib/assert/is-capitalized"
+isCentrosymmetricMatrix,"@stdlib/assert/is-centrosymmetric-matrix"
+isCircular,"@stdlib/assert/is-circular"
+isCircularArray,"@stdlib/assert/is-circular-array"
+isCircularPlainObject,"@stdlib/assert/is-circular-plain-object"
+isCollection,"@stdlib/assert/is-collection"
+isComplex,"@stdlib/assert/is-complex"
+isComplex64,"@stdlib/assert/is-complex64"
+isComplex64Array,"@stdlib/assert/is-complex64array"
+isComplex128,"@stdlib/assert/is-complex128"
+isComplex128Array,"@stdlib/assert/is-complex128array"
+isComplexLike,"@stdlib/assert/is-complex-like"
+isComplexTypedArray,"@stdlib/assert/is-complex-typed-array"
+isConfigurableProperty,"@stdlib/assert/is-configurable-property"
+isConfigurablePropertyIn,"@stdlib/assert/is-configurable-property-in"
+isDataProperty,"@stdlib/assert/is-data-property"
+isDataPropertyIn,"@stdlib/assert/is-data-property-in"
+isDateObject,"@stdlib/assert/is-date-object"
+isDigitString,"@stdlib/assert/is-digit-string"
+isEmailAddress,"@stdlib/assert/is-email-address"
+isEmptyArray,"@stdlib/assert/is-empty-array"
+isEmptyObject,"@stdlib/assert/is-empty-object"
+isEmptyString,"@stdlib/assert/is-empty-string"
+isEnumerableProperty,"@stdlib/assert/is-enumerable-property"
+isEnumerablePropertyIn,"@stdlib/assert/is-enumerable-property-in"
+isError,"@stdlib/assert/is-error"
+isEvalError,"@stdlib/assert/is-eval-error"
+isEven,"@stdlib/assert/is-even"
+isFalsy,"@stdlib/assert/is-falsy"
+isFalsyArray,"@stdlib/assert/is-falsy-array"
+isFinite,"@stdlib/assert/is-finite"
+isFiniteArray,"@stdlib/assert/is-finite-array"
+isFloat32Array,"@stdlib/assert/is-float32array"
+isFloat64Array,"@stdlib/assert/is-float64array"
+isFunction,"@stdlib/assert/is-function"
+isFunctionArray,"@stdlib/assert/is-function-array"
+isGeneratorObject,"@stdlib/assert/is-generator-object"
+isGeneratorObjectLike,"@stdlib/assert/is-generator-object-like"
+isHexString,"@stdlib/assert/is-hex-string"
+isInfinite,"@stdlib/assert/is-infinite"
+isInheritedProperty,"@stdlib/assert/is-inherited-property"
+isInt8Array,"@stdlib/assert/is-int8array"
+isInt16Array,"@stdlib/assert/is-int16array"
+isInt32Array,"@stdlib/assert/is-int32array"
+isInteger,"@stdlib/assert/is-integer"
+isIntegerArray,"@stdlib/assert/is-integer-array"
+isIterableLike,"@stdlib/assert/is-iterable-like"
+isIteratorLike,"@stdlib/assert/is-iterator-like"
+isJSON,"@stdlib/assert/is-json"
+isLeapYear,"@stdlib/assert/is-leap-year"
+isLowercase,"@stdlib/assert/is-lowercase"
+isMatrixLike,"@stdlib/assert/is-matrix-like"
+isMethod,"@stdlib/assert/is-method"
+isMethodIn,"@stdlib/assert/is-method-in"
+isNamedTypedTupleLike,"@stdlib/assert/is-named-typed-tuple-like"
+isnan,"@stdlib/assert/is-nan"
+isNaNArray,"@stdlib/assert/is-nan-array"
+isNativeFunction,"@stdlib/assert/is-native-function"
+isndarrayLike,"@stdlib/assert/is-ndarray-like"
+isNegativeInteger,"@stdlib/assert/is-negative-integer"
+isNegativeIntegerArray,"@stdlib/assert/is-negative-integer-array"
+isNegativeNumber,"@stdlib/assert/is-negative-number"
+isNegativeNumberArray,"@stdlib/assert/is-negative-number-array"
+isNegativeZero,"@stdlib/assert/is-negative-zero"
+isNodeBuiltin,"@stdlib/assert/is-node-builtin"
+isNodeDuplexStreamLike,"@stdlib/assert/is-node-duplex-stream-like"
+isNodeReadableStreamLike,"@stdlib/assert/is-node-readable-stream-like"
+isNodeREPL,"@stdlib/assert/is-node-repl"
+isNodeStreamLike,"@stdlib/assert/is-node-stream-like"
+isNodeTransformStreamLike,"@stdlib/assert/is-node-transform-stream-like"
+isNodeWritableStreamLike,"@stdlib/assert/is-node-writable-stream-like"
+isNonConfigurableProperty,"@stdlib/assert/is-nonconfigurable-property"
+isNonConfigurablePropertyIn,"@stdlib/assert/is-nonconfigurable-property-in"
+isNonEnumerableProperty,"@stdlib/assert/is-nonenumerable-property"
+isNonEnumerablePropertyIn,"@stdlib/assert/is-nonenumerable-property-in"
+isNonNegativeInteger,"@stdlib/assert/is-nonnegative-integer"
+isNonNegativeIntegerArray,"@stdlib/assert/is-nonnegative-integer-array"
+isNonNegativeNumber,"@stdlib/assert/is-nonnegative-number"
+isNonNegativeNumberArray,"@stdlib/assert/is-nonnegative-number-array"
+isNonPositiveInteger,"@stdlib/assert/is-nonpositive-integer"
+isNonPositiveIntegerArray,"@stdlib/assert/is-nonpositive-integer-array"
+isNonPositiveNumber,"@stdlib/assert/is-nonpositive-number"
+isNonPositiveNumberArray,"@stdlib/assert/is-nonpositive-number-array"
+isNonSymmetricMatrix,"@stdlib/assert/is-nonsymmetric-matrix"
+isNull,"@stdlib/assert/is-null"
+isNullArray,"@stdlib/assert/is-null-array"
+isNumber,"@stdlib/assert/is-number"
+isNumberArray,"@stdlib/assert/is-number-array"
+isNumericArray,"@stdlib/assert/is-numeric-array"
+isObject,"@stdlib/assert/is-object"
+isObjectArray,"@stdlib/assert/is-object-array"
+isObjectLike,"@stdlib/assert/is-object-like"
+isOdd,"@stdlib/assert/is-odd"
+isoWeeksInYear,"@stdlib/time/iso-weeks-in-year"
+isPersymmetricMatrix,"@stdlib/assert/is-persymmetric-matrix"
+isPlainObject,"@stdlib/assert/is-plain-object"
+isPlainObjectArray,"@stdlib/assert/is-plain-object-array"
+isPositiveInteger,"@stdlib/assert/is-positive-integer"
+isPositiveIntegerArray,"@stdlib/assert/is-positive-integer-array"
+isPositiveNumber,"@stdlib/assert/is-positive-number"
+isPositiveNumberArray,"@stdlib/assert/is-positive-number-array"
+isPositiveZero,"@stdlib/assert/is-positive-zero"
+isPrimitive,"@stdlib/assert/is-primitive"
+isPrimitiveArray,"@stdlib/assert/is-primitive-array"
+isPRNGLike,"@stdlib/assert/is-prng-like"
+isProbability,"@stdlib/assert/is-probability"
+isProbabilityArray,"@stdlib/assert/is-probability-array"
+isPrototypeOf,"@stdlib/assert/is-prototype-of"
+isRangeError,"@stdlib/assert/is-range-error"
+isReadableProperty,"@stdlib/assert/is-readable-property"
+isReadablePropertyIn,"@stdlib/assert/is-readable-property-in"
+isReadOnlyProperty,"@stdlib/assert/is-read-only-property"
+isReadOnlyPropertyIn,"@stdlib/assert/is-read-only-property-in"
+isReadWriteProperty,"@stdlib/assert/is-read-write-property"
+isReadWritePropertyIn,"@stdlib/assert/is-read-write-property-in"
+isReferenceError,"@stdlib/assert/is-reference-error"
+isRegExp,"@stdlib/assert/is-regexp"
+isRegExpString,"@stdlib/assert/is-regexp-string"
+isRelativePath,"@stdlib/assert/is-relative-path"
+isSafeInteger,"@stdlib/assert/is-safe-integer"
+isSafeIntegerArray,"@stdlib/assert/is-safe-integer-array"
+isSameValue,"@stdlib/assert/is-same-value"
+isSameValueZero,"@stdlib/assert/is-same-value-zero"
+isSharedArrayBuffer,"@stdlib/assert/is-sharedarraybuffer"
+isSkewCentrosymmetricMatrix,"@stdlib/assert/is-skew-centrosymmetric-matrix"
+isSkewPersymmetricMatrix,"@stdlib/assert/is-skew-persymmetric-matrix"
+isSkewSymmetricMatrix,"@stdlib/assert/is-skew-symmetric-matrix"
+isSquareMatrix,"@stdlib/assert/is-square-matrix"
+isStrictEqual,"@stdlib/assert/is-strict-equal"
+isString,"@stdlib/assert/is-string"
+isStringArray,"@stdlib/assert/is-string-array"
+isSymbol,"@stdlib/assert/is-symbol"
+isSymbolArray,"@stdlib/assert/is-symbol-array"
+isSymmetricMatrix,"@stdlib/assert/is-symmetric-matrix"
+isSyntaxError,"@stdlib/assert/is-syntax-error"
+isTruthy,"@stdlib/assert/is-truthy"
+isTruthyArray,"@stdlib/assert/is-truthy-array"
+isTypedArray,"@stdlib/assert/is-typed-array"
+isTypedArrayLength,"@stdlib/assert/is-typed-array-length"
+isTypedArrayLike,"@stdlib/assert/is-typed-array-like"
+isTypeError,"@stdlib/assert/is-type-error"
+isUint8Array,"@stdlib/assert/is-uint8array"
+isUint8ClampedArray,"@stdlib/assert/is-uint8clampedarray"
+isUint16Array,"@stdlib/assert/is-uint16array"
+isUint32Array,"@stdlib/assert/is-uint32array"
+isUNCPath,"@stdlib/assert/is-unc-path"
+isUndefined,"@stdlib/assert/is-undefined"
+isUndefinedOrNull,"@stdlib/assert/is-undefined-or-null"
+isUnityProbabilityArray,"@stdlib/assert/is-unity-probability-array"
+isUppercase,"@stdlib/assert/is-uppercase"
+isURI,"@stdlib/assert/is-uri"
+isURIError,"@stdlib/assert/is-uri-error"
+isVectorLike,"@stdlib/assert/is-vector-like"
+isWhitespace,"@stdlib/assert/is-whitespace"
+isWritableProperty,"@stdlib/assert/is-writable-property"
+isWritablePropertyIn,"@stdlib/assert/is-writable-property-in"
+isWriteOnlyProperty,"@stdlib/assert/is-write-only-property"
+isWriteOnlyPropertyIn,"@stdlib/assert/is-write-only-property-in"
+iterAdd,"@stdlib/math/iter/add"
+iterAdvance,"@stdlib/iter/advance"
+iterAny,"@stdlib/iter/any"
+iterAnyBy,"@stdlib/iter/any-by"
+iterator2array,"@stdlib/array/from-iterator"
+iterator2arrayview,"@stdlib/iter/to-array-view"
+iterator2arrayviewRight,"@stdlib/iter/to-array-view-right"
+iteratorStream,"@stdlib/streams/node/from-iterator"
+IteratorSymbol,"@stdlib/symbol/iterator"
+iterawgn,"@stdlib/simulate/iter/awgn"
+iterawln,"@stdlib/simulate/iter/awln"
+iterawun,"@stdlib/simulate/iter/awun"
+iterBartlettHannPulse,"@stdlib/simulate/iter/bartlett-hann-pulse"
+iterBartlettPulse,"@stdlib/simulate/iter/bartlett-pulse"
+iterConcat,"@stdlib/iter/concat"
+iterConstant,"@stdlib/iter/constant"
+iterCosineWave,"@stdlib/simulate/iter/cosine-wave"
+iterCounter,"@stdlib/iter/counter"
+itercugmean,"@stdlib/stats/iter/cugmean"
+itercuhmean,"@stdlib/stats/iter/cuhmean"
+itercumax,"@stdlib/stats/iter/cumax"
+itercumaxabs,"@stdlib/stats/iter/cumaxabs"
+itercumean,"@stdlib/stats/iter/cumean"
+itercumeanabs,"@stdlib/stats/iter/cumeanabs"
+itercumeanabs2,"@stdlib/stats/iter/cumeanabs2"
+itercumidrange,"@stdlib/stats/iter/cumidrange"
+itercumin,"@stdlib/stats/iter/cumin"
+itercuminabs,"@stdlib/stats/iter/cuminabs"
+itercuprod,"@stdlib/stats/iter/cuprod"
+itercurange,"@stdlib/stats/iter/curange"
+itercusum,"@stdlib/stats/iter/cusum"
+itercusumabs,"@stdlib/stats/iter/cusumabs"
+itercusumabs2,"@stdlib/stats/iter/cusumabs2"
+iterDedupe,"@stdlib/iter/dedupe"
+iterDedupeBy,"@stdlib/iter/dedupe-by"
+iterDiracComb,"@stdlib/simulate/iter/dirac-comb"
+iterDivide,"@stdlib/math/iter/divide"
+iterEmpty,"@stdlib/iter/empty"
+iterEvery,"@stdlib/iter/every"
+iterEveryBy,"@stdlib/iter/every-by"
+iterFibonacci,"@stdlib/math/iter/fibonacci"
+iterFill,"@stdlib/iter/fill"
+iterFilter,"@stdlib/iter/filter"
+iterFilterMap,"@stdlib/iter/filter-map"
+iterFirst,"@stdlib/iter/first"
+iterFlatTopPulse,"@stdlib/simulate/iter/flat-top-pulse"
+iterFlow,"@stdlib/iter/flow"
+iterForEach,"@stdlib/iter/for-each"
+iterHannPulse,"@stdlib/simulate/iter/hann-pulse"
+iterHead,"@stdlib/iter/head"
+iterIntersection,"@stdlib/iter/intersection"
+iterIntersectionByHash,"@stdlib/iter/intersection-by-hash"
+iterLanczosPulse,"@stdlib/simulate/iter/lanczos-pulse"
+iterLast,"@stdlib/iter/last"
+iterLength,"@stdlib/iter/length"
+iterMap,"@stdlib/iter/map"
+iterMapN,"@stdlib/iter/mapn"
+itermax,"@stdlib/stats/iter/max"
+itermaxabs,"@stdlib/stats/iter/maxabs"
+itermean,"@stdlib/stats/iter/mean"
+itermeanabs,"@stdlib/stats/iter/meanabs"
+itermeanabs2,"@stdlib/stats/iter/meanabs2"
+itermidrange,"@stdlib/stats/iter/midrange"
+itermin,"@stdlib/stats/iter/min"
+iterminabs,"@stdlib/stats/iter/minabs"
+itermmax,"@stdlib/stats/iter/mmax"
+itermmaxabs,"@stdlib/stats/iter/mmaxabs"
+itermmean,"@stdlib/stats/iter/mmean"
+itermmeanabs,"@stdlib/stats/iter/mmeanabs"
+itermmeanabs2,"@stdlib/stats/iter/mmeanabs2"
+itermmidrange,"@stdlib/stats/iter/mmidrange"
+itermmin,"@stdlib/stats/iter/mmin"
+itermminabs,"@stdlib/stats/iter/mminabs"
+iterMod,"@stdlib/math/iter/mod"
+itermprod,"@stdlib/stats/iter/mprod"
+itermrange,"@stdlib/stats/iter/mrange"
+itermsum,"@stdlib/stats/iter/msum"
+itermsumabs,"@stdlib/stats/iter/msumabs"
+itermsumabs2,"@stdlib/stats/iter/msumabs2"
+iterMultiply,"@stdlib/math/iter/multiply"
+iterNone,"@stdlib/iter/none"
+iterNoneBy,"@stdlib/iter/none-by"
+iterNonFibonacci,"@stdlib/math/iter/nonfibonacci"
+iterNth,"@stdlib/iter/nth"
+iterPeriodicSinc,"@stdlib/simulate/iter/periodic-sinc"
+iterPipeline,"@stdlib/iter/pipeline"
+iterPop,"@stdlib/iter/pop"
+iterprod,"@stdlib/stats/iter/prod"
+iterPulse,"@stdlib/simulate/iter/pulse"
+iterPush,"@stdlib/iter/push"
+iterrange,"@stdlib/stats/iter/range"
+iterReject,"@stdlib/iter/reject"
+iterReplicate,"@stdlib/iter/replicate"
+iterReplicateBy,"@stdlib/iter/replicate-by"
+iterSawtoothWave,"@stdlib/simulate/iter/sawtooth-wave"
+iterShift,"@stdlib/iter/shift"
+iterSineWave,"@stdlib/simulate/iter/sine-wave"
+iterSlice,"@stdlib/iter/slice"
+iterSome,"@stdlib/iter/some"
+iterSomeBy,"@stdlib/iter/some-by"
+iterSquareWave,"@stdlib/simulate/iter/square-wave"
+iterstdev,"@stdlib/stats/iter/stdev"
+iterSubtract,"@stdlib/math/iter/subtract"
+itersum,"@stdlib/stats/iter/sum"
+itersumabs,"@stdlib/stats/iter/sumabs"
+itersumabs2,"@stdlib/stats/iter/sumabs2"
+iterThunk,"@stdlib/iter/pipeline-thunk"
+iterTriangleWave,"@stdlib/simulate/iter/triangle-wave"
+iterUnion,"@stdlib/iter/union"
+iterUnique,"@stdlib/iter/unique"
+iterUniqueBy,"@stdlib/iter/unique-by"
+iterUniqueByHash,"@stdlib/iter/unique-by-hash"
+iterUnshift,"@stdlib/iter/unshift"
+itervariance,"@stdlib/stats/iter/variance"
+joinStream,"@stdlib/streams/node/join"
+kde2d,"@stdlib/stats/kde2d"
+keyBy,"@stdlib/utils/key-by"
+keyByRight,"@stdlib/utils/key-by-right"
+keysIn,"@stdlib/utils/keys-in"
+kruskalTest,"@stdlib/stats/kruskal-test"
+kstest,"@stdlib/stats/kstest"
+lda,"@stdlib/nlp/lda"
+LinkedList,"@stdlib/utils/linked-list"
+linspace,"@stdlib/math/utils/linspace"
+LIU_NEGATIVE_OPINION_WORDS_EN,"@stdlib/datasets/liu-negative-opinion-words-en"
+LIU_POSITIVE_OPINION_WORDS_EN,"@stdlib/datasets/liu-positive-opinion-words-en"
+LN_HALF,"@stdlib/constants/math/float64-ln-half"
+LN_PI,"@stdlib/constants/math/float64-ln-pi"
+LN_SQRT_TWO_PI,"@stdlib/constants/math/float64-ln-sqrt-two-pi"
+LN_TWO_PI,"@stdlib/constants/math/float64-ln-two-pi"
+LN2,"@stdlib/constants/math/float64-ln-two"
+LN10,"@stdlib/constants/math/float64-ln-ten"
+LOG2E,"@stdlib/constants/math/float64-log2-e"
+LOG10E,"@stdlib/constants/math/float64-log10-e"
+logspace,"@stdlib/math/utils/logspace"
+lowercase,"@stdlib/string/lowercase"
+lowercaseKeys,"@stdlib/utils/lowercase-keys"
+lowess,"@stdlib/stats/lowess"
+lpad,"@stdlib/string/left-pad"
+ltrim,"@stdlib/string/left-trim"
+MALE_FIRST_NAMES_EN,"@stdlib/datasets/male-first-names-en"
+mapFun,"@stdlib/utils/map-function"
+mapFunAsync,"@stdlib/utils/async/map-function"
+mapKeys,"@stdlib/utils/map-keys"
+mapKeysAsync,"@stdlib/utils/async/map-keys"
+mapValues,"@stdlib/utils/map-values"
+mapValuesAsync,"@stdlib/utils/async/map-values"
+MAX_ARRAY_LENGTH,"@stdlib/constants/array/max-array-length"
+MAX_TYPED_ARRAY_LENGTH,"@stdlib/constants/array/max-typed-array-length"
+memoize,"@stdlib/utils/memoize"
+merge,"@stdlib/utils/merge"
+MILLISECONDS_IN_DAY,"@stdlib/constants/time/milliseconds-in-day"
+MILLISECONDS_IN_HOUR,"@stdlib/constants/time/milliseconds-in-hour"
+MILLISECONDS_IN_MINUTE,"@stdlib/constants/time/milliseconds-in-minute"
+MILLISECONDS_IN_SECOND,"@stdlib/constants/time/milliseconds-in-second"
+MILLISECONDS_IN_WEEK,"@stdlib/constants/time/milliseconds-in-week"
+MINARD_NAPOLEONS_MARCH,"@stdlib/datasets/minard-napoleons-march"
+MINUTES_IN_DAY,"@stdlib/constants/time/minutes-in-day"
+MINUTES_IN_HOUR,"@stdlib/constants/time/minutes-in-hour"
+MINUTES_IN_WEEK,"@stdlib/constants/time/minutes-in-week"
+minutesInMonth,"@stdlib/time/minutes-in-month"
+minutesInYear,"@stdlib/time/minutes-in-year"
+MOBY_DICK,"@stdlib/datasets/moby-dick"
+MONTH_NAMES_EN,"@stdlib/datasets/month-names-en"
+MONTHS_IN_YEAR,"@stdlib/constants/time/months-in-year"
+moveProperty,"@stdlib/utils/move-property"
+namedtypedtuple,"@stdlib/utils/named-typed-tuple"
+nativeClass,"@stdlib/utils/native-class"
+ndarray,"@stdlib/ndarray/ctor"
+ndarrayCastingModes,"@stdlib/ndarray/casting-modes"
+ndarrayDataTypes,"@stdlib/ndarray/dtypes"
+ndarrayIndexModes,"@stdlib/ndarray/index-modes"
+ndarrayMemoized,"@stdlib/ndarray/memoized-ctor"
+ndarrayMinDataType,"@stdlib/ndarray/min-dtype"
+ndarrayNextDataType,"@stdlib/ndarray/next-dtype"
+ndarrayOrders,"@stdlib/ndarray/orders"
+ndarrayPromotionRules,"@stdlib/ndarray/promotion-rules"
+ndarraySafeCasts,"@stdlib/ndarray/safe-casts"
+ndarraySameKindCasts,"@stdlib/ndarray/same-kind-casts"
+NIGHTINGALES_ROSE,"@stdlib/datasets/nightingales-rose"
+NINF,"@stdlib/constants/math/float64-ninf"
+NODE_VERSION,"@stdlib/process/node-version"
+none,"@stdlib/utils/none"
+noneBy,"@stdlib/utils/none-by"
+noneByAsync,"@stdlib/utils/async/none-by"
+noneByRight,"@stdlib/utils/none-by-right"
+noneByRightAsync,"@stdlib/utils/async/none-by-right"
+nonEnumerableProperties,"@stdlib/utils/nonenumerable-properties"
+nonEnumerablePropertiesIn,"@stdlib/utils/nonenumerable-properties-in"
+nonEnumerablePropertyNames,"@stdlib/utils/nonenumerable-property-names"
+nonEnumerablePropertyNamesIn,"@stdlib/utils/nonenumerable-property-names-in"
+nonEnumerablePropertySymbols,"@stdlib/utils/nonenumerable-property-symbols"
+nonEnumerablePropertySymbolsIn,"@stdlib/utils/nonenumerable-property-symbols-in"
+noop,"@stdlib/utils/noop"
+now,"@stdlib/time/now"
+NUM_CPUS,"@stdlib/os/num-cpus"
+Number,"@stdlib/number/ctor"
+objectEntries,"@stdlib/utils/entries"
+objectEntriesIn,"@stdlib/utils/entries-in"
+objectFromEntries,"@stdlib/utils/from-entries"
+objectInverse,"@stdlib/utils/object-inverse"
+objectInverseBy,"@stdlib/utils/object-inverse-by"
+objectKeys,"@stdlib/utils/keys"
+objectValues,"@stdlib/utils/values"
+objectValuesIn,"@stdlib/utils/values-in"
+omit,"@stdlib/utils/omit"
+omitBy,"@stdlib/utils/omit-by"
+onlineBinaryClassification,"@stdlib/ml/online-binary-classification"
+onlineSGDRegression,"@stdlib/ml/online-sgd-regression"
+openURL,"@stdlib/utils/open-url"
+PACE_BOSTON_HOUSE_PRICES,"@stdlib/datasets/pace-boston-house-prices"
+pad,"@stdlib/string/pad"
+papply,"@stdlib/utils/papply"
+papplyRight,"@stdlib/utils/papply-right"
+parallel,"@stdlib/utils/parallel"
+parseJSON,"@stdlib/utils/parse-json"
+PATH_DELIMITER,"@stdlib/constants/string/path-delimiter"
+PATH_DELIMITER_POSIX,"@stdlib/constants/string/path-delimiter-posix"
+PATH_DELIMITER_WIN32,"@stdlib/constants/string/path-delimiter-win32"
+PATH_SEP,"@stdlib/constants/string/path-sep"
+PATH_SEP_POSIX,"@stdlib/constants/string/path-sep-posix"
+PATH_SEP_WIN32,"@stdlib/constants/string/path-sep-win32"
+pcorrtest,"@stdlib/stats/pcorrtest"
+percentEncode,"@stdlib/string/percent-encode"
+PHI,"@stdlib/constants/math/float64-phi"
+PI,"@stdlib/constants/math/float64-pi"
+PI_SQUARED,"@stdlib/constants/math/float64-pi-squared"
+pick,"@stdlib/utils/pick"
+pickBy,"@stdlib/utils/pick-by"
+PINF,"@stdlib/constants/math/float64-pinf"
+pkg2alias,"@stdlib/namespace/pkg2alias"
+pkg2related,"@stdlib/namespace/pkg2related"
+PLATFORM,"@stdlib/os/platform"
+plot,"@stdlib/plot"
+Plot,"@stdlib/plot/ctor"
+pluck,"@stdlib/utils/pluck"
+pop,"@stdlib/utils/pop"
+prepend,"@stdlib/utils/prepend"
+properties,"@stdlib/utils/properties"
+propertiesIn,"@stdlib/utils/properties-in"
+propertyDescriptor,"@stdlib/utils/property-descriptor"
+propertyDescriptorIn,"@stdlib/utils/property-descriptor-in"
+propertyDescriptors,"@stdlib/utils/property-descriptors"
+propertyDescriptorsIn,"@stdlib/utils/property-descriptors-in"
+propertyNames,"@stdlib/utils/property-names"
+propertyNamesIn,"@stdlib/utils/property-names-in"
+propertySymbols,"@stdlib/utils/property-symbols"
+propertySymbolsIn,"@stdlib/utils/property-symbols-in"
+Proxy,"@stdlib/proxy/ctor"
+push,"@stdlib/utils/push"
+quarterOfYear,"@stdlib/time/quarter-of-year"
+random.iterators.arcsine,"@stdlib/random/iter/arcsine"
+random.iterators.bernoulli,"@stdlib/random/iter/bernoulli"
+random.iterators.beta,"@stdlib/random/iter/beta"
+random.iterators.betaprime,"@stdlib/random/iter/betaprime"
+random.iterators.binomial,"@stdlib/random/iter/binomial"
+random.iterators.boxMuller,"@stdlib/random/iter/box-muller"
+random.iterators.cauchy,"@stdlib/random/iter/cauchy"
+random.iterators.chi,"@stdlib/random/iter/chi"
+random.iterators.chisquare,"@stdlib/random/iter/chisquare"
+random.iterators.cosine,"@stdlib/random/iter/cosine"
+random.iterators.discreteUniform,"@stdlib/random/iter/discrete-uniform"
+random.iterators.erlang,"@stdlib/random/iter/erlang"
+random.iterators.exponential,"@stdlib/random/iter/exponential"
+random.iterators.f,"@stdlib/random/iter/f"
+random.iterators.frechet,"@stdlib/random/iter/frechet"
+random.iterators.gamma,"@stdlib/random/iter/gamma"
+random.iterators.geometric,"@stdlib/random/iter/geometric"
+random.iterators.gumbel,"@stdlib/random/iter/gumbel"
+random.iterators.hypergeometric,"@stdlib/random/iter/hypergeometric"
+random.iterators.improvedZiggurat,"@stdlib/random/iter/improved-ziggurat"
+random.iterators.invgamma,"@stdlib/random/iter/invgamma"
+random.iterators.kumaraswamy,"@stdlib/random/iter/kumaraswamy"
+random.iterators.laplace,"@stdlib/random/iter/laplace"
+random.iterators.levy,"@stdlib/random/iter/levy"
+random.iterators.logistic,"@stdlib/random/iter/logistic"
+random.iterators.lognormal,"@stdlib/random/iter/lognormal"
+random.iterators.minstd,"@stdlib/random/iter/minstd"
+random.iterators.minstdShuffle,"@stdlib/random/iter/minstd-shuffle"
+random.iterators.mt19937,"@stdlib/random/iter/mt19937"
+random.iterators.negativeBinomial,"@stdlib/random/iter/negative-binomial"
+random.iterators.normal,"@stdlib/random/iter/normal"
+random.iterators.pareto1,"@stdlib/random/iter/pareto-type1"
+random.iterators.poisson,"@stdlib/random/iter/poisson"
+random.iterators.randi,"@stdlib/random/iter/randi"
+random.iterators.randn,"@stdlib/random/iter/randn"
+random.iterators.randu,"@stdlib/random/iter/randu"
+random.iterators.rayleigh,"@stdlib/random/iter/rayleigh"
+random.iterators.t,"@stdlib/random/iter/t"
+random.iterators.triangular,"@stdlib/random/iter/triangular"
+random.iterators.uniform,"@stdlib/random/iter/uniform"
+random.iterators.weibull,"@stdlib/random/iter/weibull"
+random.streams.arcsine,"@stdlib/random/streams/arcsine"
+random.streams.bernoulli,"@stdlib/random/streams/bernoulli"
+random.streams.beta,"@stdlib/random/streams/beta"
+random.streams.betaprime,"@stdlib/random/streams/betaprime"
+random.streams.binomial,"@stdlib/random/streams/binomial"
+random.streams.boxMuller,"@stdlib/random/streams/box-muller"
+random.streams.cauchy,"@stdlib/random/streams/cauchy"
+random.streams.chi,"@stdlib/random/streams/chi"
+random.streams.chisquare,"@stdlib/random/streams/chisquare"
+random.streams.cosine,"@stdlib/random/streams/cosine"
+random.streams.discreteUniform,"@stdlib/random/streams/discrete-uniform"
+random.streams.erlang,"@stdlib/random/streams/erlang"
+random.streams.exponential,"@stdlib/random/streams/exponential"
+random.streams.f,"@stdlib/random/streams/f"
+random.streams.gamma,"@stdlib/random/streams/gamma"
+random.streams.geometric,"@stdlib/random/streams/geometric"
+random.streams.gumbel,"@stdlib/random/streams/gumbel"
+random.streams.improvedZiggurat,"@stdlib/random/streams/improved-ziggurat"
+random.streams.invgamma,"@stdlib/random/streams/invgamma"
+random.streams.kumaraswamy,"@stdlib/random/streams/kumaraswamy"
+random.streams.laplace,"@stdlib/random/streams/laplace"
+random.streams.levy,"@stdlib/random/streams/levy"
+random.streams.logistic,"@stdlib/random/streams/logistic"
+random.streams.lognormal,"@stdlib/random/streams/lognormal"
+random.streams.minstd,"@stdlib/random/streams/minstd"
+random.streams.minstdShuffle,"@stdlib/random/streams/minstd-shuffle"
+random.streams.mt19937,"@stdlib/random/streams/mt19937"
+random.streams.negativeBinomial,"@stdlib/random/streams/negative-binomial"
+random.streams.normal,"@stdlib/random/streams/normal"
+random.streams.pareto1,"@stdlib/random/streams/pareto-type1"
+random.streams.poisson,"@stdlib/random/streams/poisson"
+random.streams.randi,"@stdlib/random/streams/randi"
+random.streams.randn,"@stdlib/random/streams/randn"
+random.streams.randu,"@stdlib/random/streams/randu"
+random.streams.rayleigh,"@stdlib/random/streams/rayleigh"
+random.streams.t,"@stdlib/random/streams/t"
+random.streams.uniform,"@stdlib/random/streams/uniform"
+random.streams.weibull,"@stdlib/random/streams/weibull"
+ranks,"@stdlib/stats/ranks"
+RE_BASENAME,"@stdlib/regexp/basename"
+RE_BASENAME_POSIX,"@stdlib/regexp/basename-posix"
+RE_BASENAME_WINDOWS,"@stdlib/regexp/basename-windows"
+RE_COLOR_HEXADECIMAL,"@stdlib/regexp/color-hexadecimal"
+RE_DECIMAL_NUMBER,"@stdlib/regexp/decimal-number"
+RE_DIRNAME,"@stdlib/regexp/dirname"
+RE_DIRNAME_POSIX,"@stdlib/regexp/dirname-posix"
+RE_DIRNAME_WINDOWS,"@stdlib/regexp/dirname-windows"
+RE_EOL,"@stdlib/regexp/eol"
+RE_EXTENDED_LENGTH_PATH,"@stdlib/regexp/extended-length-path"
+RE_EXTNAME,"@stdlib/regexp/extname"
+RE_EXTNAME_POSIX,"@stdlib/regexp/extname-posix"
+RE_EXTNAME_WINDOWS,"@stdlib/regexp/extname-windows"
+RE_FILENAME,"@stdlib/regexp/filename"
+RE_FILENAME_POSIX,"@stdlib/regexp/filename-posix"
+RE_FILENAME_WINDOWS,"@stdlib/regexp/filename-windows"
+RE_FUNCTION_NAME,"@stdlib/regexp/function-name"
+RE_NATIVE_FUNCTION,"@stdlib/regexp/native-function"
+RE_REGEXP,"@stdlib/regexp/regexp"
+RE_UNC_PATH,"@stdlib/regexp/unc-path"
+RE_UTF16_SURROGATE_PAIR,"@stdlib/regexp/utf16-surrogate-pair"
+RE_UTF16_UNPAIRED_SURROGATE,"@stdlib/regexp/utf16-unpaired-surrogate"
+RE_WHITESPACE,"@stdlib/regexp/whitespace"
+readDir,"@stdlib/fs/read-dir"
+readFile,"@stdlib/fs/read-file"
+readFileList,"@stdlib/fs/read-file-list"
+readJSON,"@stdlib/fs/read-json"
+readWASM,"@stdlib/fs/read-wasm"
+real,"@stdlib/complex/real"
+realmax,"@stdlib/utils/real-max"
+realmin,"@stdlib/utils/real-min"
+reduce,"@stdlib/utils/reduce"
+reduceAsync,"@stdlib/utils/async/reduce"
+reduceRight,"@stdlib/utils/reduce-right"
+reduceRightAsync,"@stdlib/utils/async/reduce-right"
+reFromString,"@stdlib/utils/regexp-from-string"
+reim,"@stdlib/complex/reim"
+removeFirst,"@stdlib/string/remove-first"
+removeLast,"@stdlib/string/remove-last"
+removePunctuation,"@stdlib/string/remove-punctuation"
+removeUTF8BOM,"@stdlib/string/remove-utf8-bom"
+removeWords,"@stdlib/string/remove-words"
+rename,"@stdlib/fs/rename"
+reorderArguments,"@stdlib/utils/reorder-arguments"
+repeat,"@stdlib/string/repeat"
+replace,"@stdlib/string/replace"
+rescape,"@stdlib/utils/escape-regexp-string"
+resolveParentPath,"@stdlib/fs/resolve-parent-path"
+reverseArguments,"@stdlib/utils/reverse-arguments"
+reverseString,"@stdlib/string/reverse"
+reviveBasePRNG,"@stdlib/random/base/reviver"
+reviveBuffer,"@stdlib/buffer/reviver"
+reviveComplex,"@stdlib/complex/reviver"
+reviveComplex64,"@stdlib/complex/reviver-float32"
+reviveComplex128,"@stdlib/complex/reviver-float64"
+reviveError,"@stdlib/error/reviver"
+reviveTypedArray,"@stdlib/array/reviver"
+rpad,"@stdlib/string/right-pad"
+rtrim,"@stdlib/string/right-trim"
+safeintmax,"@stdlib/utils/safe-int-max"
+safeintmin,"@stdlib/utils/safe-int-min"
+sample,"@stdlib/random/sample"
+SAVOY_STOPWORDS_FIN,"@stdlib/datasets/savoy-stopwords-fin"
+SAVOY_STOPWORDS_FR,"@stdlib/datasets/savoy-stopwords-fr"
+SAVOY_STOPWORDS_GER,"@stdlib/datasets/savoy-stopwords-ger"
+SAVOY_STOPWORDS_IT,"@stdlib/datasets/savoy-stopwords-it"
+SAVOY_STOPWORDS_POR,"@stdlib/datasets/savoy-stopwords-por"
+SAVOY_STOPWORDS_SP,"@stdlib/datasets/savoy-stopwords-sp"
+SAVOY_STOPWORDS_SWE,"@stdlib/datasets/savoy-stopwords-swe"
+SECONDS_IN_DAY,"@stdlib/constants/time/seconds-in-day"
+SECONDS_IN_HOUR,"@stdlib/constants/time/seconds-in-hour"
+SECONDS_IN_MINUTE,"@stdlib/constants/time/seconds-in-minute"
+SECONDS_IN_WEEK,"@stdlib/constants/time/seconds-in-week"
+secondsInMonth,"@stdlib/time/seconds-in-month"
+secondsInYear,"@stdlib/time/seconds-in-year"
+setConfigurableReadOnly,"@stdlib/utils/define-configurable-read-only-property"
+setConfigurableReadOnlyAccessor,"@stdlib/utils/define-configurable-read-only-accessor"
+setConfigurableReadWriteAccessor,"@stdlib/utils/define-configurable-read-write-accessor"
+setConfigurableWriteOnlyAccessor,"@stdlib/utils/define-configurable-write-only-accessor"
+setMemoizedReadOnly,"@stdlib/utils/define-memoized-read-only-property"
+setNonEnumerableProperty,"@stdlib/utils/define-nonenumerable-property"
+setNonEnumerableReadOnly,"@stdlib/utils/define-nonenumerable-read-only-property"
+setNonEnumerableReadOnlyAccessor,"@stdlib/utils/define-nonenumerable-read-only-accessor"
+setNonEnumerableReadWriteAccessor,"@stdlib/utils/define-nonenumerable-read-write-accessor"
+setNonEnumerableWriteOnlyAccessor,"@stdlib/utils/define-nonenumerable-write-only-accessor"
+setReadOnly,"@stdlib/utils/define-read-only-property"
+setReadOnlyAccessor,"@stdlib/utils/define-read-only-accessor"
+setReadWriteAccessor,"@stdlib/utils/define-read-write-accessor"
+setWriteOnlyAccessor,"@stdlib/utils/define-write-only-accessor"
+SharedArrayBuffer,"@stdlib/array/shared-buffer"
+shift,"@stdlib/utils/shift"
+shuffle,"@stdlib/random/shuffle"
+sizeOf,"@stdlib/utils/size-of"
+some,"@stdlib/utils/some"
+someBy,"@stdlib/utils/some-by"
+someByAsync,"@stdlib/utils/async/some-by"
+someByRight,"@stdlib/utils/some-by-right"
+someByRightAsync,"@stdlib/utils/async/some-by-right"
+SOTU,"@stdlib/datasets/sotu"
+SPACHE_REVISED,"@stdlib/datasets/spache-revised"
+SPAM_ASSASSIN,"@stdlib/datasets/spam-assassin"
+SparklineBase,"@stdlib/plot/sparklines/base/ctor"
+sparsearray2iterator,"@stdlib/array/to-sparse-iterator"
+sparsearray2iteratorRight,"@stdlib/array/to-sparse-iterator-right"
+splitStream,"@stdlib/streams/node/split"
+SQRT_EPS,"@stdlib/constants/math/float64-sqrt-eps"
+SQRT_HALF,"@stdlib/constants/math/float64-sqrt-half"
+SQRT_HALF_PI,"@stdlib/constants/math/float64-sqrt-half-pi"
+SQRT_PHI,"@stdlib/constants/math/float64-sqrt-phi"
+SQRT_PI,"@stdlib/constants/math/float64-sqrt-pi"
+SQRT_THREE,"@stdlib/constants/math/float64-sqrt-three"
+SQRT_TWO,"@stdlib/constants/math/float64-sqrt-two"
+SQRT_TWO_PI,"@stdlib/constants/math/float64-sqrt-two-pi"
+Stack,"@stdlib/utils/stack"
+startcase,"@stdlib/string/startcase"
+startsWith,"@stdlib/string/starts-with"
+STOPWORDS_EN,"@stdlib/datasets/stopwords-en"
+stridedarray2iterator,"@stdlib/array/to-strided-iterator"
+stridedArrayStream,"@stdlib/streams/node/from-strided-array"
+string2buffer,"@stdlib/buffer/from-string"
+sub2ind,"@stdlib/ndarray/sub2ind"
+SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK,"@stdlib/datasets/suthaharan-multi-hop-sensor-network"
+SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK,"@stdlib/datasets/suthaharan-single-hop-sensor-network"
+Symbol,"@stdlib/symbol/ctor"
+tabulate,"@stdlib/utils/tabulate"
+tabulateBy,"@stdlib/utils/tabulate-by"
+tabulateByAsync,"@stdlib/utils/async/tabulate-by"
+tic,"@stdlib/time/tic"
+timeit,"@stdlib/utils/timeit"
+tmpdir,"@stdlib/os/tmpdir"
+toc,"@stdlib/time/toc"
+tokenize,"@stdlib/nlp/tokenize"
+transformStream,"@stdlib/streams/node/transform"
+trim,"@stdlib/string/trim"
+trycatch,"@stdlib/utils/try-catch"
+trycatchAsync,"@stdlib/utils/async/try-catch"
+tryFunction,"@stdlib/utils/try-function"
+tryRequire,"@stdlib/utils/try-require"
+trythen,"@stdlib/utils/try-then"
+trythenAsync,"@stdlib/utils/async/try-then"
+ttest,"@stdlib/stats/ttest"
+ttest2,"@stdlib/stats/ttest2"
+TWO_PI,"@stdlib/constants/math/float64-two-pi"
+typedarray,"@stdlib/array/typed"
+typedarray2json,"@stdlib/array/to-json"
+typedarrayComplexCtors,"@stdlib/array/typed-complex-ctors"
+typedarrayComplexDataTypes,"@stdlib/array/typed-complex-dtypes"
+typedarrayCtors,"@stdlib/array/typed-ctors"
+typedarrayDataTypes,"@stdlib/array/typed-dtypes"
+typedarraypool,"@stdlib/array/pool"
+typemax,"@stdlib/utils/type-max"
+typemin,"@stdlib/utils/type-min"
+typeOf,"@stdlib/utils/type-of"
+UINT8_MAX,"@stdlib/constants/math/uint8-max"
+UINT8_NUM_BYTES,"@stdlib/constants/math/uint8-num-bytes"
+Uint8Array,"@stdlib/array/uint8"
+Uint8ClampedArray,"@stdlib/array/uint8c"
+UINT16_MAX,"@stdlib/constants/math/uint16-max"
+UINT16_NUM_BYTES,"@stdlib/constants/math/uint16-num-bytes"
+Uint16Array,"@stdlib/array/uint16"
+UINT32_MAX,"@stdlib/constants/math/uint32-max"
+UINT32_NUM_BYTES,"@stdlib/constants/math/uint32-num-bytes"
+Uint32Array,"@stdlib/array/uint32"
+umask,"@stdlib/process/umask"
+uncapitalize,"@stdlib/string/uncapitalize"
+uncapitalizeKeys,"@stdlib/utils/uncapitalize-keys"
+uncurry,"@stdlib/utils/uncurry"
+uncurryRight,"@stdlib/utils/uncurry-right"
+UNICODE_MAX,"@stdlib/constants/string/unicode-max"
+UNICODE_MAX_BMP,"@stdlib/constants/string/unicode-max-bmp"
+UnicodeColumnChartSparkline,"@stdlib/plot/sparklines/unicode/column"
+UnicodeLineChartSparkline,"@stdlib/plot/sparklines/unicode/line"
+UnicodeSparkline,"@stdlib/plot/sparklines/unicode"
+UnicodeTristateChartSparkline,"@stdlib/plot/sparklines/unicode/tristate"
+UnicodeUpDownChartSparkline,"@stdlib/plot/sparklines/unicode/up-down"
+UnicodeWinLossChartSparkline,"@stdlib/plot/sparklines/unicode/win-loss"
+unlink,"@stdlib/fs/unlink"
+unshift,"@stdlib/utils/unshift"
+until,"@stdlib/utils/until"
+untilAsync,"@stdlib/utils/async/until"
+untilEach,"@stdlib/utils/until-each"
+untilEachRight,"@stdlib/utils/until-each-right"
+unzip,"@stdlib/utils/unzip"
+uppercase,"@stdlib/string/uppercase"
+uppercaseKeys,"@stdlib/utils/uppercase-keys"
+US_STATES_ABBR,"@stdlib/datasets/us-states-abbr"
+US_STATES_CAPITALS,"@stdlib/datasets/us-states-capitals"
+US_STATES_CAPITALS_NAMES,"@stdlib/datasets/us-states-capitals-names"
+US_STATES_NAMES,"@stdlib/datasets/us-states-names"
+US_STATES_NAMES_CAPITALS,"@stdlib/datasets/us-states-names-capitals"
+utf16ToUTF8Array,"@stdlib/string/utf16-to-utf8-array"
+vartest,"@stdlib/stats/vartest"
+waterfall,"@stdlib/utils/async/series-waterfall"
+whileAsync,"@stdlib/utils/async/while"
+whileEach,"@stdlib/utils/while-each"
+whileEachRight,"@stdlib/utils/while-each-right"
+whilst,"@stdlib/utils/while"
+writableProperties,"@stdlib/utils/writable-properties"
+writablePropertiesIn,"@stdlib/utils/writable-properties-in"
+writablePropertyNames,"@stdlib/utils/writable-property-names"
+writablePropertyNamesIn,"@stdlib/utils/writable-property-names-in"
+writablePropertySymbols,"@stdlib/utils/writable-property-symbols"
+writablePropertySymbolsIn,"@stdlib/utils/writable-property-symbols-in"
+writeFile,"@stdlib/fs/write-file"
+zip,"@stdlib/utils/zip"
+ztest,"@stdlib/stats/ztest"
+ztest2,"@stdlib/stats/ztest2"
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json
new file mode 100644
index 000000000000..6e619cfb570e
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/data/data.json
@@ -0,0 +1 @@
+{"AFINN_96":"@stdlib/datasets/afinn-96","AFINN_111":"@stdlib/datasets/afinn-111","alias2pkg":"@stdlib/namespace/alias2pkg","alias2related":"@stdlib/namespace/alias2related","aliases":"@stdlib/namespace/aliases","allocUnsafe":"@stdlib/buffer/alloc-unsafe","anova1":"@stdlib/stats/anova1","ANSCOMBES_QUARTET":"@stdlib/datasets/anscombes-quartet","any":"@stdlib/utils/any","anyBy":"@stdlib/utils/any-by","anyByAsync":"@stdlib/utils/async/any-by","anyByRight":"@stdlib/utils/any-by-right","anyByRightAsync":"@stdlib/utils/async/any-by-right","APERY":"@stdlib/constants/math/float64-apery","append":"@stdlib/utils/append","ARCH":"@stdlib/os/arch","argumentFunction":"@stdlib/utils/argument-function","ARGV":"@stdlib/process/argv","array":"@stdlib/ndarray/array","array2buffer":"@stdlib/buffer/from-array","array2iterator":"@stdlib/array/to-iterator","array2iteratorRight":"@stdlib/array/to-iterator-right","ArrayBuffer":"@stdlib/array/buffer","arraybuffer2buffer":"@stdlib/buffer/from-arraybuffer","arrayCtors":"@stdlib/array/ctors","arrayDataType":"@stdlib/array/dtype","arrayDataTypes":"@stdlib/array/dtypes","arrayMinDataType":"@stdlib/array/min-dtype","arrayNextDataType":"@stdlib/array/next-dtype","arrayPromotionRules":"@stdlib/array/promotion-rules","arraySafeCasts":"@stdlib/array/safe-casts","arraySameKindCasts":"@stdlib/array/same-kind-casts","arrayShape":"@stdlib/array/shape","arrayStream":"@stdlib/streams/node/from-array","arrayview2iterator":"@stdlib/array/to-view-iterator","arrayview2iteratorRight":"@stdlib/array/to-view-iterator-right","AsyncIteratorSymbol":"@stdlib/symbol/async-iterator","bartlettTest":"@stdlib/stats/bartlett-test","base.abs":"@stdlib/math/base/special/abs","base.abs2":"@stdlib/math/base/special/abs2","base.absdiff":"@stdlib/math/base/utils/absolute-difference","base.absInt32":"@stdlib/math/base/special/int32-abs","base.acos":"@stdlib/math/base/special/acos","base.acosh":"@stdlib/math/base/special/acosh","base.acoth":"@stdlib/math/base/special/acoth","base.acovercos":"@stdlib/math/base/special/acovercos","base.acoversin":"@stdlib/math/base/special/acoversin","base.ahavercos":"@stdlib/math/base/special/ahavercos","base.ahaversin":"@stdlib/math/base/special/ahaversin","base.asin":"@stdlib/math/base/special/asin","base.asinh":"@stdlib/math/base/special/asinh","base.atan":"@stdlib/math/base/special/atan","base.atan2":"@stdlib/math/base/special/atan2","base.atanh":"@stdlib/math/base/special/atanh","base.avercos":"@stdlib/math/base/special/avercos","base.aversin":"@stdlib/math/base/special/aversin","base.bernoulli":"@stdlib/math/base/special/bernoulli","base.besselj0":"@stdlib/math/base/special/besselj0","base.besselj1":"@stdlib/math/base/special/besselj1","base.bessely0":"@stdlib/math/base/special/bessely0","base.bessely1":"@stdlib/math/base/special/bessely1","base.beta":"@stdlib/math/base/special/beta","base.betainc":"@stdlib/math/base/special/betainc","base.betaincinv":"@stdlib/math/base/special/betaincinv","base.betaln":"@stdlib/math/base/special/betaln","base.binet":"@stdlib/math/base/special/binet","base.binomcoef":"@stdlib/math/base/special/binomcoef","base.binomcoefln":"@stdlib/math/base/special/binomcoefln","base.boxcox":"@stdlib/math/base/special/boxcox","base.boxcox1p":"@stdlib/math/base/special/boxcox1p","base.boxcox1pinv":"@stdlib/math/base/special/boxcox1pinv","base.boxcoxinv":"@stdlib/math/base/special/boxcoxinv","base.cabs":"@stdlib/math/base/complex/abs","base.cabs2":"@stdlib/math/base/complex/abs2","base.cadd":"@stdlib/math/base/complex/add","base.cbrt":"@stdlib/math/base/special/cbrt","base.cceil":"@stdlib/math/base/complex/ceil","base.cceiln":"@stdlib/math/base/complex/ceiln","base.ccis":"@stdlib/math/base/complex/cis","base.cdiv":"@stdlib/math/base/complex/divide","base.ceil":"@stdlib/math/base/special/ceil","base.ceil2":"@stdlib/math/base/special/ceil2","base.ceil10":"@stdlib/math/base/special/ceil10","base.ceilb":"@stdlib/math/base/special/ceilb","base.ceiln":"@stdlib/math/base/special/ceiln","base.ceilsd":"@stdlib/math/base/special/ceilsd","base.cexp":"@stdlib/math/base/complex/exp","base.cflipsign":"@stdlib/math/base/complex/flipsign","base.cfloor":"@stdlib/math/base/complex/floor","base.cfloorn":"@stdlib/math/base/complex/floorn","base.cinv":"@stdlib/math/base/complex/inv","base.clamp":"@stdlib/math/base/special/clamp","base.cmul":"@stdlib/math/base/complex/multiply","base.cneg":"@stdlib/math/base/complex/negate","base.continuedFraction":"@stdlib/math/base/tools/continued-fraction","base.copysign":"@stdlib/math/base/special/copysign","base.cos":"@stdlib/math/base/special/cos","base.cosh":"@stdlib/math/base/special/cosh","base.cosm1":"@stdlib/math/base/special/cosm1","base.cospi":"@stdlib/math/base/special/cospi","base.covercos":"@stdlib/math/base/special/covercos","base.coversin":"@stdlib/math/base/special/coversin","base.cphase":"@stdlib/math/base/complex/phase","base.cpolar":"@stdlib/math/base/complex/polar","base.cround":"@stdlib/math/base/complex/round","base.croundn":"@stdlib/math/base/complex/roundn","base.csignum":"@stdlib/math/base/complex/signum","base.csub":"@stdlib/math/base/complex/subtract","base.dasum":"@stdlib/blas/base/dasum","base.daxpy":"@stdlib/blas/base/daxpy","base.dcopy":"@stdlib/blas/base/dcopy","base.deg2rad":"@stdlib/math/base/special/deg2rad","base.digamma":"@stdlib/math/base/special/digamma","base.diracDelta":"@stdlib/math/base/special/dirac-delta","base.dists.arcsine.Arcsine":"@stdlib/stats/base/dists/arcsine/ctor","base.dists.arcsine.cdf":"@stdlib/stats/base/dists/arcsine/cdf","base.dists.arcsine.entropy":"@stdlib/stats/base/dists/arcsine/entropy","base.dists.arcsine.kurtosis":"@stdlib/stats/base/dists/arcsine/kurtosis","base.dists.arcsine.logcdf":"@stdlib/stats/base/dists/arcsine/logcdf","base.dists.arcsine.logpdf":"@stdlib/stats/base/dists/arcsine/logpdf","base.dists.arcsine.mean":"@stdlib/stats/base/dists/arcsine/mean","base.dists.arcsine.median":"@stdlib/stats/base/dists/arcsine/median","base.dists.arcsine.mode":"@stdlib/stats/base/dists/arcsine/mode","base.dists.arcsine.pdf":"@stdlib/stats/base/dists/arcsine/pdf","base.dists.arcsine.quantile":"@stdlib/stats/base/dists/arcsine/quantile","base.dists.arcsine.skewness":"@stdlib/stats/base/dists/arcsine/skewness","base.dists.arcsine.stdev":"@stdlib/stats/base/dists/arcsine/stdev","base.dists.arcsine.variance":"@stdlib/stats/base/dists/arcsine/variance","base.dists.bernoulli.Bernoulli":"@stdlib/stats/base/dists/bernoulli/ctor","base.dists.bernoulli.cdf":"@stdlib/stats/base/dists/bernoulli/cdf","base.dists.bernoulli.entropy":"@stdlib/stats/base/dists/bernoulli/entropy","base.dists.bernoulli.kurtosis":"@stdlib/stats/base/dists/bernoulli/kurtosis","base.dists.bernoulli.mean":"@stdlib/stats/base/dists/bernoulli/mean","base.dists.bernoulli.median":"@stdlib/stats/base/dists/bernoulli/median","base.dists.bernoulli.mgf":"@stdlib/stats/base/dists/bernoulli/mgf","base.dists.bernoulli.mode":"@stdlib/stats/base/dists/bernoulli/mode","base.dists.bernoulli.pmf":"@stdlib/stats/base/dists/bernoulli/pmf","base.dists.bernoulli.quantile":"@stdlib/stats/base/dists/bernoulli/quantile","base.dists.bernoulli.skewness":"@stdlib/stats/base/dists/bernoulli/skewness","base.dists.bernoulli.stdev":"@stdlib/stats/base/dists/bernoulli/stdev","base.dists.bernoulli.variance":"@stdlib/stats/base/dists/bernoulli/variance","base.dists.beta.Beta":"@stdlib/stats/base/dists/beta/ctor","base.dists.beta.cdf":"@stdlib/stats/base/dists/beta/cdf","base.dists.beta.entropy":"@stdlib/stats/base/dists/beta/entropy","base.dists.beta.kurtosis":"@stdlib/stats/base/dists/beta/kurtosis","base.dists.beta.logcdf":"@stdlib/stats/base/dists/beta/logcdf","base.dists.beta.logpdf":"@stdlib/stats/base/dists/beta/logpdf","base.dists.beta.mean":"@stdlib/stats/base/dists/beta/mean","base.dists.beta.median":"@stdlib/stats/base/dists/beta/median","base.dists.beta.mgf":"@stdlib/stats/base/dists/beta/mgf","base.dists.beta.mode":"@stdlib/stats/base/dists/beta/mode","base.dists.beta.pdf":"@stdlib/stats/base/dists/beta/pdf","base.dists.beta.quantile":"@stdlib/stats/base/dists/beta/quantile","base.dists.beta.skewness":"@stdlib/stats/base/dists/beta/skewness","base.dists.beta.stdev":"@stdlib/stats/base/dists/beta/stdev","base.dists.beta.variance":"@stdlib/stats/base/dists/beta/variance","base.dists.betaprime.BetaPrime":"@stdlib/stats/base/dists/betaprime/ctor","base.dists.betaprime.cdf":"@stdlib/stats/base/dists/betaprime/cdf","base.dists.betaprime.kurtosis":"@stdlib/stats/base/dists/betaprime/kurtosis","base.dists.betaprime.logcdf":"@stdlib/stats/base/dists/betaprime/logcdf","base.dists.betaprime.logpdf":"@stdlib/stats/base/dists/betaprime/logpdf","base.dists.betaprime.mean":"@stdlib/stats/base/dists/betaprime/mean","base.dists.betaprime.mode":"@stdlib/stats/base/dists/betaprime/mode","base.dists.betaprime.pdf":"@stdlib/stats/base/dists/betaprime/pdf","base.dists.betaprime.quantile":"@stdlib/stats/base/dists/betaprime/quantile","base.dists.betaprime.skewness":"@stdlib/stats/base/dists/betaprime/skewness","base.dists.betaprime.stdev":"@stdlib/stats/base/dists/betaprime/stdev","base.dists.betaprime.variance":"@stdlib/stats/base/dists/betaprime/variance","base.dists.binomial.Binomial":"@stdlib/stats/base/dists/binomial/ctor","base.dists.binomial.cdf":"@stdlib/stats/base/dists/binomial/cdf","base.dists.binomial.entropy":"@stdlib/stats/base/dists/binomial/entropy","base.dists.binomial.kurtosis":"@stdlib/stats/base/dists/binomial/kurtosis","base.dists.binomial.logpmf":"@stdlib/stats/base/dists/binomial/logpmf","base.dists.binomial.mean":"@stdlib/stats/base/dists/binomial/mean","base.dists.binomial.median":"@stdlib/stats/base/dists/binomial/median","base.dists.binomial.mgf":"@stdlib/stats/base/dists/binomial/mgf","base.dists.binomial.mode":"@stdlib/stats/base/dists/binomial/mode","base.dists.binomial.pmf":"@stdlib/stats/base/dists/binomial/pmf","base.dists.binomial.quantile":"@stdlib/stats/base/dists/binomial/quantile","base.dists.binomial.skewness":"@stdlib/stats/base/dists/binomial/skewness","base.dists.binomial.stdev":"@stdlib/stats/base/dists/binomial/stdev","base.dists.binomial.variance":"@stdlib/stats/base/dists/binomial/variance","base.dists.cauchy.Cauchy":"@stdlib/stats/base/dists/cauchy/ctor","base.dists.cauchy.cdf":"@stdlib/stats/base/dists/cauchy/cdf","base.dists.cauchy.entropy":"@stdlib/stats/base/dists/cauchy/entropy","base.dists.cauchy.logcdf":"@stdlib/stats/base/dists/cauchy/logcdf","base.dists.cauchy.logpdf":"@stdlib/stats/base/dists/cauchy/logpdf","base.dists.cauchy.median":"@stdlib/stats/base/dists/cauchy/median","base.dists.cauchy.mode":"@stdlib/stats/base/dists/cauchy/mode","base.dists.cauchy.pdf":"@stdlib/stats/base/dists/cauchy/pdf","base.dists.cauchy.quantile":"@stdlib/stats/base/dists/cauchy/quantile","base.dists.chi.cdf":"@stdlib/stats/base/dists/chi/cdf","base.dists.chi.Chi":"@stdlib/stats/base/dists/chi/ctor","base.dists.chi.entropy":"@stdlib/stats/base/dists/chi/entropy","base.dists.chi.kurtosis":"@stdlib/stats/base/dists/chi/kurtosis","base.dists.chi.logpdf":"@stdlib/stats/base/dists/chi/logpdf","base.dists.chi.mean":"@stdlib/stats/base/dists/chi/mean","base.dists.chi.mode":"@stdlib/stats/base/dists/chi/mode","base.dists.chi.pdf":"@stdlib/stats/base/dists/chi/pdf","base.dists.chi.quantile":"@stdlib/stats/base/dists/chi/quantile","base.dists.chi.skewness":"@stdlib/stats/base/dists/chi/skewness","base.dists.chi.stdev":"@stdlib/stats/base/dists/chi/stdev","base.dists.chi.variance":"@stdlib/stats/base/dists/chi/variance","base.dists.chisquare.cdf":"@stdlib/stats/base/dists/chisquare/cdf","base.dists.chisquare.ChiSquare":"@stdlib/stats/base/dists/chisquare/ctor","base.dists.chisquare.entropy":"@stdlib/stats/base/dists/chisquare/entropy","base.dists.chisquare.kurtosis":"@stdlib/stats/base/dists/chisquare/kurtosis","base.dists.chisquare.logpdf":"@stdlib/stats/base/dists/chisquare/logpdf","base.dists.chisquare.mean":"@stdlib/stats/base/dists/chisquare/mean","base.dists.chisquare.mgf":"@stdlib/stats/base/dists/chisquare/mgf","base.dists.chisquare.mode":"@stdlib/stats/base/dists/chisquare/mode","base.dists.chisquare.pdf":"@stdlib/stats/base/dists/chisquare/pdf","base.dists.chisquare.quantile":"@stdlib/stats/base/dists/chisquare/quantile","base.dists.chisquare.skewness":"@stdlib/stats/base/dists/chisquare/skewness","base.dists.chisquare.stdev":"@stdlib/stats/base/dists/chisquare/stdev","base.dists.chisquare.variance":"@stdlib/stats/base/dists/chisquare/variance","base.dists.cosine.cdf":"@stdlib/stats/base/dists/cosine/cdf","base.dists.cosine.Cosine":"@stdlib/stats/base/dists/cosine/ctor","base.dists.cosine.kurtosis":"@stdlib/stats/base/dists/cosine/kurtosis","base.dists.cosine.logcdf":"@stdlib/stats/base/dists/cosine/logcdf","base.dists.cosine.logpdf":"@stdlib/stats/base/dists/cosine/logpdf","base.dists.cosine.mean":"@stdlib/stats/base/dists/cosine/mean","base.dists.cosine.median":"@stdlib/stats/base/dists/cosine/median","base.dists.cosine.mgf":"@stdlib/stats/base/dists/cosine/mgf","base.dists.cosine.mode":"@stdlib/stats/base/dists/cosine/mode","base.dists.cosine.pdf":"@stdlib/stats/base/dists/cosine/pdf","base.dists.cosine.quantile":"@stdlib/stats/base/dists/cosine/quantile","base.dists.cosine.skewness":"@stdlib/stats/base/dists/cosine/skewness","base.dists.cosine.stdev":"@stdlib/stats/base/dists/cosine/stdev","base.dists.cosine.variance":"@stdlib/stats/base/dists/cosine/variance","base.dists.degenerate.cdf":"@stdlib/stats/base/dists/degenerate/cdf","base.dists.degenerate.Degenerate":"@stdlib/stats/base/dists/degenerate/ctor","base.dists.degenerate.entropy":"@stdlib/stats/base/dists/degenerate/entropy","base.dists.degenerate.logcdf":"@stdlib/stats/base/dists/degenerate/logcdf","base.dists.degenerate.logpdf":"@stdlib/stats/base/dists/degenerate/logpdf","base.dists.degenerate.logpmf":"@stdlib/stats/base/dists/degenerate/logpmf","base.dists.degenerate.mean":"@stdlib/stats/base/dists/degenerate/mean","base.dists.degenerate.median":"@stdlib/stats/base/dists/degenerate/median","base.dists.degenerate.mgf":"@stdlib/stats/base/dists/degenerate/mgf","base.dists.degenerate.mode":"@stdlib/stats/base/dists/degenerate/mode","base.dists.degenerate.pdf":"@stdlib/stats/base/dists/degenerate/pdf","base.dists.degenerate.pmf":"@stdlib/stats/base/dists/degenerate/pmf","base.dists.degenerate.quantile":"@stdlib/stats/base/dists/degenerate/quantile","base.dists.degenerate.stdev":"@stdlib/stats/base/dists/degenerate/stdev","base.dists.degenerate.variance":"@stdlib/stats/base/dists/degenerate/variance","base.dists.discreteUniform.cdf":"@stdlib/stats/base/dists/discrete-uniform/cdf","base.dists.discreteUniform.DiscreteUniform":"@stdlib/stats/base/dists/discrete-uniform/ctor","base.dists.discreteUniform.kurtosis":"@stdlib/stats/base/dists/discrete-uniform/kurtosis","base.dists.discreteUniform.logcdf":"@stdlib/stats/base/dists/discrete-uniform/logcdf","base.dists.discreteUniform.logpmf":"@stdlib/stats/base/dists/discrete-uniform/logpmf","base.dists.discreteUniform.mean":"@stdlib/stats/base/dists/discrete-uniform/mean","base.dists.discreteUniform.median":"@stdlib/stats/base/dists/discrete-uniform/median","base.dists.discreteUniform.mgf":"@stdlib/stats/base/dists/discrete-uniform/mgf","base.dists.discreteUniform.pmf":"@stdlib/stats/base/dists/discrete-uniform/pmf","base.dists.discreteUniform.quantile":"@stdlib/stats/base/dists/discrete-uniform/quantile","base.dists.discreteUniform.skewness":"@stdlib/stats/base/dists/discrete-uniform/skewness","base.dists.discreteUniform.stdev":"@stdlib/stats/base/dists/discrete-uniform/stdev","base.dists.discreteUniform.variance":"@stdlib/stats/base/dists/discrete-uniform/variance","base.dists.erlang.cdf":"@stdlib/stats/base/dists/erlang/cdf","base.dists.erlang.entropy":"@stdlib/stats/base/dists/erlang/entropy","base.dists.erlang.Erlang":"@stdlib/stats/base/dists/erlang/ctor","base.dists.erlang.kurtosis":"@stdlib/stats/base/dists/erlang/kurtosis","base.dists.erlang.logpdf":"@stdlib/stats/base/dists/erlang/logpdf","base.dists.erlang.mean":"@stdlib/stats/base/dists/erlang/mean","base.dists.erlang.mgf":"@stdlib/stats/base/dists/erlang/mgf","base.dists.erlang.mode":"@stdlib/stats/base/dists/erlang/mode","base.dists.erlang.pdf":"@stdlib/stats/base/dists/erlang/pdf","base.dists.erlang.quantile":"@stdlib/stats/base/dists/erlang/quantile","base.dists.erlang.skewness":"@stdlib/stats/base/dists/erlang/skewness","base.dists.erlang.stdev":"@stdlib/stats/base/dists/erlang/stdev","base.dists.erlang.variance":"@stdlib/stats/base/dists/erlang/variance","base.dists.exponential.cdf":"@stdlib/stats/base/dists/exponential/cdf","base.dists.exponential.entropy":"@stdlib/stats/base/dists/exponential/entropy","base.dists.exponential.Exponential":"@stdlib/stats/base/dists/exponential/ctor","base.dists.exponential.kurtosis":"@stdlib/stats/base/dists/exponential/kurtosis","base.dists.exponential.logcdf":"@stdlib/stats/base/dists/exponential/logcdf","base.dists.exponential.logpdf":"@stdlib/stats/base/dists/exponential/logpdf","base.dists.exponential.mean":"@stdlib/stats/base/dists/exponential/mean","base.dists.exponential.median":"@stdlib/stats/base/dists/exponential/median","base.dists.exponential.mgf":"@stdlib/stats/base/dists/exponential/mgf","base.dists.exponential.mode":"@stdlib/stats/base/dists/exponential/mode","base.dists.exponential.pdf":"@stdlib/stats/base/dists/exponential/pdf","base.dists.exponential.quantile":"@stdlib/stats/base/dists/exponential/quantile","base.dists.exponential.skewness":"@stdlib/stats/base/dists/exponential/skewness","base.dists.exponential.stdev":"@stdlib/stats/base/dists/exponential/stdev","base.dists.exponential.variance":"@stdlib/stats/base/dists/exponential/variance","base.dists.f.cdf":"@stdlib/stats/base/dists/f/cdf","base.dists.f.entropy":"@stdlib/stats/base/dists/f/entropy","base.dists.f.F":"@stdlib/stats/base/dists/f/ctor","base.dists.f.kurtosis":"@stdlib/stats/base/dists/f/kurtosis","base.dists.f.mean":"@stdlib/stats/base/dists/f/mean","base.dists.f.mode":"@stdlib/stats/base/dists/f/mode","base.dists.f.pdf":"@stdlib/stats/base/dists/f/pdf","base.dists.f.quantile":"@stdlib/stats/base/dists/f/quantile","base.dists.f.skewness":"@stdlib/stats/base/dists/f/skewness","base.dists.f.stdev":"@stdlib/stats/base/dists/f/stdev","base.dists.f.variance":"@stdlib/stats/base/dists/f/variance","base.dists.frechet.cdf":"@stdlib/stats/base/dists/frechet/cdf","base.dists.frechet.entropy":"@stdlib/stats/base/dists/frechet/entropy","base.dists.frechet.Frechet":"@stdlib/stats/base/dists/frechet/ctor","base.dists.frechet.kurtosis":"@stdlib/stats/base/dists/frechet/kurtosis","base.dists.frechet.logcdf":"@stdlib/stats/base/dists/frechet/logcdf","base.dists.frechet.logpdf":"@stdlib/stats/base/dists/frechet/logpdf","base.dists.frechet.mean":"@stdlib/stats/base/dists/frechet/mean","base.dists.frechet.median":"@stdlib/stats/base/dists/frechet/median","base.dists.frechet.mode":"@stdlib/stats/base/dists/frechet/mode","base.dists.frechet.pdf":"@stdlib/stats/base/dists/frechet/pdf","base.dists.frechet.quantile":"@stdlib/stats/base/dists/frechet/quantile","base.dists.frechet.skewness":"@stdlib/stats/base/dists/frechet/skewness","base.dists.frechet.stdev":"@stdlib/stats/base/dists/frechet/stdev","base.dists.frechet.variance":"@stdlib/stats/base/dists/frechet/variance","base.dists.gamma.cdf":"@stdlib/stats/base/dists/gamma/cdf","base.dists.gamma.entropy":"@stdlib/stats/base/dists/gamma/entropy","base.dists.gamma.Gamma":"@stdlib/stats/base/dists/gamma/ctor","base.dists.gamma.kurtosis":"@stdlib/stats/base/dists/gamma/kurtosis","base.dists.gamma.logpdf":"@stdlib/stats/base/dists/gamma/logpdf","base.dists.gamma.mean":"@stdlib/stats/base/dists/gamma/mean","base.dists.gamma.mgf":"@stdlib/stats/base/dists/gamma/mgf","base.dists.gamma.mode":"@stdlib/stats/base/dists/gamma/mode","base.dists.gamma.pdf":"@stdlib/stats/base/dists/gamma/pdf","base.dists.gamma.quantile":"@stdlib/stats/base/dists/gamma/quantile","base.dists.gamma.skewness":"@stdlib/stats/base/dists/gamma/skewness","base.dists.gamma.stdev":"@stdlib/stats/base/dists/gamma/stdev","base.dists.gamma.variance":"@stdlib/stats/base/dists/gamma/variance","base.dists.geometric.cdf":"@stdlib/stats/base/dists/geometric/cdf","base.dists.geometric.entropy":"@stdlib/stats/base/dists/geometric/entropy","base.dists.geometric.Geometric":"@stdlib/stats/base/dists/geometric/ctor","base.dists.geometric.kurtosis":"@stdlib/stats/base/dists/geometric/kurtosis","base.dists.geometric.logcdf":"@stdlib/stats/base/dists/geometric/logcdf","base.dists.geometric.logpmf":"@stdlib/stats/base/dists/geometric/logpmf","base.dists.geometric.mean":"@stdlib/stats/base/dists/geometric/mean","base.dists.geometric.median":"@stdlib/stats/base/dists/geometric/median","base.dists.geometric.mgf":"@stdlib/stats/base/dists/geometric/mgf","base.dists.geometric.mode":"@stdlib/stats/base/dists/geometric/mode","base.dists.geometric.pmf":"@stdlib/stats/base/dists/geometric/pmf","base.dists.geometric.quantile":"@stdlib/stats/base/dists/geometric/quantile","base.dists.geometric.skewness":"@stdlib/stats/base/dists/geometric/skewness","base.dists.geometric.stdev":"@stdlib/stats/base/dists/geometric/stdev","base.dists.geometric.variance":"@stdlib/stats/base/dists/geometric/variance","base.dists.gumbel.cdf":"@stdlib/stats/base/dists/gumbel/cdf","base.dists.gumbel.entropy":"@stdlib/stats/base/dists/gumbel/entropy","base.dists.gumbel.Gumbel":"@stdlib/stats/base/dists/gumbel/ctor","base.dists.gumbel.kurtosis":"@stdlib/stats/base/dists/gumbel/kurtosis","base.dists.gumbel.logcdf":"@stdlib/stats/base/dists/gumbel/logcdf","base.dists.gumbel.logpdf":"@stdlib/stats/base/dists/gumbel/logpdf","base.dists.gumbel.mean":"@stdlib/stats/base/dists/gumbel/mean","base.dists.gumbel.median":"@stdlib/stats/base/dists/gumbel/median","base.dists.gumbel.mgf":"@stdlib/stats/base/dists/gumbel/mgf","base.dists.gumbel.mode":"@stdlib/stats/base/dists/gumbel/mode","base.dists.gumbel.pdf":"@stdlib/stats/base/dists/gumbel/pdf","base.dists.gumbel.quantile":"@stdlib/stats/base/dists/gumbel/quantile","base.dists.gumbel.skewness":"@stdlib/stats/base/dists/gumbel/skewness","base.dists.gumbel.stdev":"@stdlib/stats/base/dists/gumbel/stdev","base.dists.gumbel.variance":"@stdlib/stats/base/dists/gumbel/variance","base.dists.hypergeometric.cdf":"@stdlib/stats/base/dists/hypergeometric/cdf","base.dists.hypergeometric.Hypergeometric":"@stdlib/stats/base/dists/hypergeometric/ctor","base.dists.hypergeometric.kurtosis":"@stdlib/stats/base/dists/hypergeometric/kurtosis","base.dists.hypergeometric.logpmf":"@stdlib/stats/base/dists/hypergeometric/logpmf","base.dists.hypergeometric.mean":"@stdlib/stats/base/dists/hypergeometric/mean","base.dists.hypergeometric.mode":"@stdlib/stats/base/dists/hypergeometric/mode","base.dists.hypergeometric.pmf":"@stdlib/stats/base/dists/hypergeometric/pmf","base.dists.hypergeometric.quantile":"@stdlib/stats/base/dists/hypergeometric/quantile","base.dists.hypergeometric.skewness":"@stdlib/stats/base/dists/hypergeometric/skewness","base.dists.hypergeometric.stdev":"@stdlib/stats/base/dists/hypergeometric/stdev","base.dists.hypergeometric.variance":"@stdlib/stats/base/dists/hypergeometric/variance","base.dists.invgamma.cdf":"@stdlib/stats/base/dists/invgamma/cdf","base.dists.invgamma.entropy":"@stdlib/stats/base/dists/invgamma/entropy","base.dists.invgamma.InvGamma":"@stdlib/stats/base/dists/invgamma/ctor","base.dists.invgamma.kurtosis":"@stdlib/stats/base/dists/invgamma/kurtosis","base.dists.invgamma.logpdf":"@stdlib/stats/base/dists/invgamma/logpdf","base.dists.invgamma.mean":"@stdlib/stats/base/dists/invgamma/mean","base.dists.invgamma.mode":"@stdlib/stats/base/dists/invgamma/mode","base.dists.invgamma.pdf":"@stdlib/stats/base/dists/invgamma/pdf","base.dists.invgamma.quantile":"@stdlib/stats/base/dists/invgamma/quantile","base.dists.invgamma.skewness":"@stdlib/stats/base/dists/invgamma/skewness","base.dists.invgamma.stdev":"@stdlib/stats/base/dists/invgamma/stdev","base.dists.invgamma.variance":"@stdlib/stats/base/dists/invgamma/variance","base.dists.kumaraswamy.cdf":"@stdlib/stats/base/dists/kumaraswamy/cdf","base.dists.kumaraswamy.Kumaraswamy":"@stdlib/stats/base/dists/kumaraswamy/ctor","base.dists.kumaraswamy.kurtosis":"@stdlib/stats/base/dists/kumaraswamy/kurtosis","base.dists.kumaraswamy.logcdf":"@stdlib/stats/base/dists/kumaraswamy/logcdf","base.dists.kumaraswamy.logpdf":"@stdlib/stats/base/dists/kumaraswamy/logpdf","base.dists.kumaraswamy.mean":"@stdlib/stats/base/dists/kumaraswamy/mean","base.dists.kumaraswamy.median":"@stdlib/stats/base/dists/kumaraswamy/median","base.dists.kumaraswamy.mode":"@stdlib/stats/base/dists/kumaraswamy/mode","base.dists.kumaraswamy.pdf":"@stdlib/stats/base/dists/kumaraswamy/pdf","base.dists.kumaraswamy.quantile":"@stdlib/stats/base/dists/kumaraswamy/quantile","base.dists.kumaraswamy.skewness":"@stdlib/stats/base/dists/kumaraswamy/skewness","base.dists.kumaraswamy.stdev":"@stdlib/stats/base/dists/kumaraswamy/stdev","base.dists.kumaraswamy.variance":"@stdlib/stats/base/dists/kumaraswamy/variance","base.dists.laplace.cdf":"@stdlib/stats/base/dists/laplace/cdf","base.dists.laplace.entropy":"@stdlib/stats/base/dists/laplace/entropy","base.dists.laplace.kurtosis":"@stdlib/stats/base/dists/laplace/kurtosis","base.dists.laplace.Laplace":"@stdlib/stats/base/dists/laplace/ctor","base.dists.laplace.logcdf":"@stdlib/stats/base/dists/laplace/logcdf","base.dists.laplace.logpdf":"@stdlib/stats/base/dists/laplace/logpdf","base.dists.laplace.mean":"@stdlib/stats/base/dists/laplace/mean","base.dists.laplace.median":"@stdlib/stats/base/dists/laplace/median","base.dists.laplace.mgf":"@stdlib/stats/base/dists/laplace/mgf","base.dists.laplace.mode":"@stdlib/stats/base/dists/laplace/mode","base.dists.laplace.pdf":"@stdlib/stats/base/dists/laplace/pdf","base.dists.laplace.quantile":"@stdlib/stats/base/dists/laplace/quantile","base.dists.laplace.skewness":"@stdlib/stats/base/dists/laplace/skewness","base.dists.laplace.stdev":"@stdlib/stats/base/dists/laplace/stdev","base.dists.laplace.variance":"@stdlib/stats/base/dists/laplace/variance","base.dists.levy.cdf":"@stdlib/stats/base/dists/levy/cdf","base.dists.levy.entropy":"@stdlib/stats/base/dists/levy/entropy","base.dists.levy.Levy":"@stdlib/stats/base/dists/levy/ctor","base.dists.levy.logcdf":"@stdlib/stats/base/dists/levy/logcdf","base.dists.levy.logpdf":"@stdlib/stats/base/dists/levy/logpdf","base.dists.levy.mean":"@stdlib/stats/base/dists/levy/mean","base.dists.levy.median":"@stdlib/stats/base/dists/levy/median","base.dists.levy.mode":"@stdlib/stats/base/dists/levy/mode","base.dists.levy.pdf":"@stdlib/stats/base/dists/levy/pdf","base.dists.levy.quantile":"@stdlib/stats/base/dists/levy/quantile","base.dists.levy.stdev":"@stdlib/stats/base/dists/levy/stdev","base.dists.levy.variance":"@stdlib/stats/base/dists/levy/variance","base.dists.logistic.cdf":"@stdlib/stats/base/dists/logistic/cdf","base.dists.logistic.entropy":"@stdlib/stats/base/dists/logistic/entropy","base.dists.logistic.kurtosis":"@stdlib/stats/base/dists/logistic/kurtosis","base.dists.logistic.logcdf":"@stdlib/stats/base/dists/logistic/logcdf","base.dists.logistic.Logistic":"@stdlib/stats/base/dists/logistic/ctor","base.dists.logistic.logpdf":"@stdlib/stats/base/dists/logistic/logpdf","base.dists.logistic.mean":"@stdlib/stats/base/dists/logistic/mean","base.dists.logistic.median":"@stdlib/stats/base/dists/logistic/median","base.dists.logistic.mgf":"@stdlib/stats/base/dists/logistic/mgf","base.dists.logistic.mode":"@stdlib/stats/base/dists/logistic/mode","base.dists.logistic.pdf":"@stdlib/stats/base/dists/logistic/pdf","base.dists.logistic.quantile":"@stdlib/stats/base/dists/logistic/quantile","base.dists.logistic.skewness":"@stdlib/stats/base/dists/logistic/skewness","base.dists.logistic.stdev":"@stdlib/stats/base/dists/logistic/stdev","base.dists.logistic.variance":"@stdlib/stats/base/dists/logistic/variance","base.dists.lognormal.cdf":"@stdlib/stats/base/dists/lognormal/cdf","base.dists.lognormal.entropy":"@stdlib/stats/base/dists/lognormal/entropy","base.dists.lognormal.kurtosis":"@stdlib/stats/base/dists/lognormal/kurtosis","base.dists.lognormal.LogNormal":"@stdlib/stats/base/dists/lognormal/ctor","base.dists.lognormal.logpdf":"@stdlib/stats/base/dists/lognormal/logpdf","base.dists.lognormal.mean":"@stdlib/stats/base/dists/lognormal/mean","base.dists.lognormal.median":"@stdlib/stats/base/dists/lognormal/median","base.dists.lognormal.mode":"@stdlib/stats/base/dists/lognormal/mode","base.dists.lognormal.pdf":"@stdlib/stats/base/dists/lognormal/pdf","base.dists.lognormal.quantile":"@stdlib/stats/base/dists/lognormal/quantile","base.dists.lognormal.skewness":"@stdlib/stats/base/dists/lognormal/skewness","base.dists.lognormal.stdev":"@stdlib/stats/base/dists/lognormal/stdev","base.dists.lognormal.variance":"@stdlib/stats/base/dists/lognormal/variance","base.dists.negativeBinomial.cdf":"@stdlib/stats/base/dists/negative-binomial/cdf","base.dists.negativeBinomial.kurtosis":"@stdlib/stats/base/dists/negative-binomial/kurtosis","base.dists.negativeBinomial.logpmf":"@stdlib/stats/base/dists/negative-binomial/logpmf","base.dists.negativeBinomial.mean":"@stdlib/stats/base/dists/negative-binomial/mean","base.dists.negativeBinomial.mgf":"@stdlib/stats/base/dists/negative-binomial/mgf","base.dists.negativeBinomial.mode":"@stdlib/stats/base/dists/negative-binomial/mode","base.dists.negativeBinomial.NegativeBinomial":"@stdlib/stats/base/dists/negative-binomial/ctor","base.dists.negativeBinomial.pmf":"@stdlib/stats/base/dists/negative-binomial/pmf","base.dists.negativeBinomial.quantile":"@stdlib/stats/base/dists/negative-binomial/quantile","base.dists.negativeBinomial.skewness":"@stdlib/stats/base/dists/negative-binomial/skewness","base.dists.negativeBinomial.stdev":"@stdlib/stats/base/dists/negative-binomial/stdev","base.dists.negativeBinomial.variance":"@stdlib/stats/base/dists/negative-binomial/variance","base.dists.normal.cdf":"@stdlib/stats/base/dists/normal/cdf","base.dists.normal.entropy":"@stdlib/stats/base/dists/normal/entropy","base.dists.normal.kurtosis":"@stdlib/stats/base/dists/normal/kurtosis","base.dists.normal.logpdf":"@stdlib/stats/base/dists/normal/logpdf","base.dists.normal.mean":"@stdlib/stats/base/dists/normal/mean","base.dists.normal.median":"@stdlib/stats/base/dists/normal/median","base.dists.normal.mgf":"@stdlib/stats/base/dists/normal/mgf","base.dists.normal.mode":"@stdlib/stats/base/dists/normal/mode","base.dists.normal.Normal":"@stdlib/stats/base/dists/normal/ctor","base.dists.normal.pdf":"@stdlib/stats/base/dists/normal/pdf","base.dists.normal.quantile":"@stdlib/stats/base/dists/normal/quantile","base.dists.normal.skewness":"@stdlib/stats/base/dists/normal/skewness","base.dists.normal.stdev":"@stdlib/stats/base/dists/normal/stdev","base.dists.normal.variance":"@stdlib/stats/base/dists/normal/variance","base.dists.pareto1.cdf":"@stdlib/stats/base/dists/pareto-type1/cdf","base.dists.pareto1.entropy":"@stdlib/stats/base/dists/pareto-type1/entropy","base.dists.pareto1.kurtosis":"@stdlib/stats/base/dists/pareto-type1/kurtosis","base.dists.pareto1.logcdf":"@stdlib/stats/base/dists/pareto-type1/logcdf","base.dists.pareto1.logpdf":"@stdlib/stats/base/dists/pareto-type1/logpdf","base.dists.pareto1.mean":"@stdlib/stats/base/dists/pareto-type1/mean","base.dists.pareto1.median":"@stdlib/stats/base/dists/pareto-type1/median","base.dists.pareto1.mode":"@stdlib/stats/base/dists/pareto-type1/mode","base.dists.pareto1.Pareto1":"@stdlib/stats/base/dists/pareto-type1/ctor","base.dists.pareto1.pdf":"@stdlib/stats/base/dists/pareto-type1/pdf","base.dists.pareto1.quantile":"@stdlib/stats/base/dists/pareto-type1/quantile","base.dists.pareto1.skewness":"@stdlib/stats/base/dists/pareto-type1/skewness","base.dists.pareto1.variance":"@stdlib/stats/base/dists/pareto-type1/variance","base.dists.poisson.cdf":"@stdlib/stats/base/dists/poisson/cdf","base.dists.poisson.entropy":"@stdlib/stats/base/dists/poisson/entropy","base.dists.poisson.kurtosis":"@stdlib/stats/base/dists/poisson/kurtosis","base.dists.poisson.logpmf":"@stdlib/stats/base/dists/poisson/logpmf","base.dists.poisson.mean":"@stdlib/stats/base/dists/poisson/mean","base.dists.poisson.median":"@stdlib/stats/base/dists/poisson/median","base.dists.poisson.mgf":"@stdlib/stats/base/dists/poisson/mgf","base.dists.poisson.mode":"@stdlib/stats/base/dists/poisson/mode","base.dists.poisson.pmf":"@stdlib/stats/base/dists/poisson/pmf","base.dists.poisson.Poisson":"@stdlib/stats/base/dists/poisson/ctor","base.dists.poisson.quantile":"@stdlib/stats/base/dists/poisson/quantile","base.dists.poisson.skewness":"@stdlib/stats/base/dists/poisson/skewness","base.dists.poisson.stdev":"@stdlib/stats/base/dists/poisson/stdev","base.dists.poisson.variance":"@stdlib/stats/base/dists/poisson/variance","base.dists.rayleigh.cdf":"@stdlib/stats/base/dists/rayleigh/cdf","base.dists.rayleigh.entropy":"@stdlib/stats/base/dists/rayleigh/entropy","base.dists.rayleigh.kurtosis":"@stdlib/stats/base/dists/rayleigh/kurtosis","base.dists.rayleigh.logcdf":"@stdlib/stats/base/dists/rayleigh/logcdf","base.dists.rayleigh.logpdf":"@stdlib/stats/base/dists/rayleigh/logpdf","base.dists.rayleigh.mean":"@stdlib/stats/base/dists/rayleigh/mean","base.dists.rayleigh.median":"@stdlib/stats/base/dists/rayleigh/median","base.dists.rayleigh.mgf":"@stdlib/stats/base/dists/rayleigh/mgf","base.dists.rayleigh.mode":"@stdlib/stats/base/dists/rayleigh/mode","base.dists.rayleigh.pdf":"@stdlib/stats/base/dists/rayleigh/pdf","base.dists.rayleigh.quantile":"@stdlib/stats/base/dists/rayleigh/quantile","base.dists.rayleigh.Rayleigh":"@stdlib/stats/base/dists/rayleigh/ctor","base.dists.rayleigh.skewness":"@stdlib/stats/base/dists/rayleigh/skewness","base.dists.rayleigh.stdev":"@stdlib/stats/base/dists/rayleigh/stdev","base.dists.rayleigh.variance":"@stdlib/stats/base/dists/rayleigh/variance","base.dists.t.cdf":"@stdlib/stats/base/dists/t/cdf","base.dists.t.entropy":"@stdlib/stats/base/dists/t/entropy","base.dists.t.kurtosis":"@stdlib/stats/base/dists/t/kurtosis","base.dists.t.mean":"@stdlib/stats/base/dists/t/mean","base.dists.t.median":"@stdlib/stats/base/dists/t/median","base.dists.t.mode":"@stdlib/stats/base/dists/t/mode","base.dists.t.pdf":"@stdlib/stats/base/dists/t/pdf","base.dists.t.quantile":"@stdlib/stats/base/dists/t/quantile","base.dists.t.skewness":"@stdlib/stats/base/dists/t/skewness","base.dists.t.stdev":"@stdlib/stats/base/dists/t/stdev","base.dists.t.T":"@stdlib/stats/base/dists/t/ctor","base.dists.t.variance":"@stdlib/stats/base/dists/t/variance","base.dists.triangular.cdf":"@stdlib/stats/base/dists/triangular/cdf","base.dists.triangular.entropy":"@stdlib/stats/base/dists/triangular/entropy","base.dists.triangular.kurtosis":"@stdlib/stats/base/dists/triangular/kurtosis","base.dists.triangular.logcdf":"@stdlib/stats/base/dists/triangular/logcdf","base.dists.triangular.logpdf":"@stdlib/stats/base/dists/triangular/logpdf","base.dists.triangular.mean":"@stdlib/stats/base/dists/triangular/mean","base.dists.triangular.median":"@stdlib/stats/base/dists/triangular/median","base.dists.triangular.mgf":"@stdlib/stats/base/dists/triangular/mgf","base.dists.triangular.mode":"@stdlib/stats/base/dists/triangular/mode","base.dists.triangular.pdf":"@stdlib/stats/base/dists/triangular/pdf","base.dists.triangular.quantile":"@stdlib/stats/base/dists/triangular/quantile","base.dists.triangular.skewness":"@stdlib/stats/base/dists/triangular/skewness","base.dists.triangular.stdev":"@stdlib/stats/base/dists/triangular/stdev","base.dists.triangular.Triangular":"@stdlib/stats/base/dists/triangular/ctor","base.dists.triangular.variance":"@stdlib/stats/base/dists/triangular/variance","base.dists.uniform.cdf":"@stdlib/stats/base/dists/uniform/cdf","base.dists.uniform.entropy":"@stdlib/stats/base/dists/uniform/entropy","base.dists.uniform.kurtosis":"@stdlib/stats/base/dists/uniform/kurtosis","base.dists.uniform.logcdf":"@stdlib/stats/base/dists/uniform/logcdf","base.dists.uniform.logpdf":"@stdlib/stats/base/dists/uniform/logpdf","base.dists.uniform.mean":"@stdlib/stats/base/dists/uniform/mean","base.dists.uniform.median":"@stdlib/stats/base/dists/uniform/median","base.dists.uniform.mgf":"@stdlib/stats/base/dists/uniform/mgf","base.dists.uniform.pdf":"@stdlib/stats/base/dists/uniform/pdf","base.dists.uniform.quantile":"@stdlib/stats/base/dists/uniform/quantile","base.dists.uniform.skewness":"@stdlib/stats/base/dists/uniform/skewness","base.dists.uniform.stdev":"@stdlib/stats/base/dists/uniform/stdev","base.dists.uniform.Uniform":"@stdlib/stats/base/dists/uniform/ctor","base.dists.uniform.variance":"@stdlib/stats/base/dists/uniform/variance","base.dists.weibull.cdf":"@stdlib/stats/base/dists/weibull/cdf","base.dists.weibull.entropy":"@stdlib/stats/base/dists/weibull/entropy","base.dists.weibull.kurtosis":"@stdlib/stats/base/dists/weibull/kurtosis","base.dists.weibull.logcdf":"@stdlib/stats/base/dists/weibull/logcdf","base.dists.weibull.logpdf":"@stdlib/stats/base/dists/weibull/logpdf","base.dists.weibull.mean":"@stdlib/stats/base/dists/weibull/mean","base.dists.weibull.median":"@stdlib/stats/base/dists/weibull/median","base.dists.weibull.mgf":"@stdlib/stats/base/dists/weibull/mgf","base.dists.weibull.mode":"@stdlib/stats/base/dists/weibull/mode","base.dists.weibull.pdf":"@stdlib/stats/base/dists/weibull/pdf","base.dists.weibull.quantile":"@stdlib/stats/base/dists/weibull/quantile","base.dists.weibull.skewness":"@stdlib/stats/base/dists/weibull/skewness","base.dists.weibull.stdev":"@stdlib/stats/base/dists/weibull/stdev","base.dists.weibull.variance":"@stdlib/stats/base/dists/weibull/variance","base.dists.weibull.Weibull":"@stdlib/stats/base/dists/weibull/ctor","base.ellipe":"@stdlib/math/base/special/ellipe","base.ellipk":"@stdlib/math/base/special/ellipk","base.epsdiff":"@stdlib/math/base/utils/float64-epsilon-difference","base.erf":"@stdlib/math/base/special/erf","base.erfc":"@stdlib/math/base/special/erfc","base.erfcinv":"@stdlib/math/base/special/erfcinv","base.erfinv":"@stdlib/math/base/special/erfinv","base.eta":"@stdlib/math/base/special/dirichlet-eta","base.evalpoly":"@stdlib/math/base/tools/evalpoly","base.evalrational":"@stdlib/math/base/tools/evalrational","base.exp":"@stdlib/math/base/special/exp","base.exp2":"@stdlib/math/base/special/exp2","base.exp10":"@stdlib/math/base/special/exp10","base.expit":"@stdlib/math/base/special/expit","base.expm1":"@stdlib/math/base/special/expm1","base.expm1rel":"@stdlib/math/base/special/expm1rel","base.exponent":"@stdlib/number/float64/base/exponent","base.exponentf":"@stdlib/number/float32/base/exponent","base.factorial":"@stdlib/math/base/special/factorial","base.factorialln":"@stdlib/math/base/special/factorialln","base.fallingFactorial":"@stdlib/math/base/special/falling-factorial","base.fibonacci":"@stdlib/math/base/special/fibonacci","base.fibonacciIndex":"@stdlib/math/base/special/fibonacci-index","base.fibpoly":"@stdlib/math/base/tools/fibpoly","base.flipsign":"@stdlib/math/base/special/flipsign","base.float32ToInt32":"@stdlib/number/float32/base/to-int32","base.float32ToUint32":"@stdlib/number/float32/base/to-uint32","base.float64ToFloat32":"@stdlib/number/float64/base/to-float32","base.float64ToInt32":"@stdlib/number/float64/base/to-int32","base.float64ToUint32":"@stdlib/number/float64/base/to-uint32","base.floor":"@stdlib/math/base/special/floor","base.floor2":"@stdlib/math/base/special/floor2","base.floor10":"@stdlib/math/base/special/floor10","base.floorb":"@stdlib/math/base/special/floorb","base.floorn":"@stdlib/math/base/special/floorn","base.floorsd":"@stdlib/math/base/special/floorsd","base.fresnel":"@stdlib/math/base/special/fresnel","base.fresnelc":"@stdlib/math/base/special/fresnelc","base.fresnels":"@stdlib/math/base/special/fresnels","base.frexp":"@stdlib/math/base/special/frexp","base.fromBinaryString":"@stdlib/number/float64/base/from-binary-string","base.fromBinaryStringf":"@stdlib/number/float32/base/from-binary-string","base.fromBinaryStringUint8":"@stdlib/number/uint8/base/from-binary-string","base.fromBinaryStringUint16":"@stdlib/number/uint16/base/from-binary-string","base.fromBinaryStringUint32":"@stdlib/number/uint32/base/from-binary-string","base.fromWordf":"@stdlib/number/float32/base/from-word","base.fromWords":"@stdlib/number/float64/base/from-words","base.gamma":"@stdlib/math/base/special/gamma","base.gamma1pm1":"@stdlib/math/base/special/gamma1pm1","base.gammaDeltaRatio":"@stdlib/math/base/special/gamma-delta-ratio","base.gammainc":"@stdlib/math/base/special/gammainc","base.gammaincinv":"@stdlib/math/base/special/gammaincinv","base.gammaLanczosSum":"@stdlib/math/base/special/gamma-lanczos-sum","base.gammaLanczosSumExpGScaled":"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","base.gammaln":"@stdlib/math/base/special/gammaln","base.gasum":"@stdlib/blas/base/gasum","base.gaxpy":"@stdlib/blas/base/gaxpy","base.gcd":"@stdlib/math/base/special/gcd","base.gcopy":"@stdlib/blas/base/gcopy","base.getHighWord":"@stdlib/number/float64/base/get-high-word","base.getLowWord":"@stdlib/number/float64/base/get-low-word","base.hacovercos":"@stdlib/math/base/special/hacovercos","base.hacoversin":"@stdlib/math/base/special/hacoversin","base.havercos":"@stdlib/math/base/special/havercos","base.haversin":"@stdlib/math/base/special/haversin","base.heaviside":"@stdlib/math/base/special/heaviside","base.hermitepoly":"@stdlib/math/base/tools/hermitepoly","base.hypot":"@stdlib/math/base/special/hypot","base.imul":"@stdlib/math/base/special/imul","base.imuldw":"@stdlib/math/base/special/imuldw","base.int32ToUint32":"@stdlib/number/int32/base/to-uint32","base.inv":"@stdlib/math/base/special/inv","base.isEven":"@stdlib/math/base/assert/is-even","base.isEvenInt32":"@stdlib/math/base/assert/int32-is-even","base.isFinite":"@stdlib/math/base/assert/is-finite","base.isInfinite":"@stdlib/math/base/assert/is-infinite","base.isInteger":"@stdlib/math/base/assert/is-integer","base.isnan":"@stdlib/math/base/assert/is-nan","base.isNegativeInteger":"@stdlib/math/base/assert/is-negative-integer","base.isNegativeZero":"@stdlib/math/base/assert/is-negative-zero","base.isNonNegativeInteger":"@stdlib/math/base/assert/is-nonnegative-integer","base.isNonPositiveInteger":"@stdlib/math/base/assert/is-nonpositive-integer","base.isOdd":"@stdlib/math/base/assert/is-odd","base.isOddInt32":"@stdlib/math/base/assert/int32-is-odd","base.isPositiveInteger":"@stdlib/math/base/assert/is-positive-integer","base.isPositiveZero":"@stdlib/math/base/assert/is-positive-zero","base.isPow2Uint32":"@stdlib/math/base/assert/uint32-is-pow2","base.isProbability":"@stdlib/math/base/assert/is-probability","base.isSafeInteger":"@stdlib/math/base/assert/is-safe-integer","base.kernelBetainc":"@stdlib/math/base/special/kernel-betainc","base.kernelBetaincinv":"@stdlib/math/base/special/kernel-betaincinv","base.kernelCos":"@stdlib/math/base/special/kernel-cos","base.kernelSin":"@stdlib/math/base/special/kernel-sin","base.kernelTan":"@stdlib/math/base/special/kernel-tan","base.kroneckerDelta":"@stdlib/math/base/special/kronecker-delta","base.lcm":"@stdlib/math/base/special/lcm","base.ldexp":"@stdlib/math/base/special/ldexp","base.ln":"@stdlib/math/base/special/ln","base.log":"@stdlib/math/base/special/log","base.log1mexp":"@stdlib/math/base/special/log1mexp","base.log1p":"@stdlib/math/base/special/log1p","base.log1pexp":"@stdlib/math/base/special/log1pexp","base.log2":"@stdlib/math/base/special/log2","base.log10":"@stdlib/math/base/special/log10","base.logaddexp":"@stdlib/math/base/special/logaddexp","base.logit":"@stdlib/math/base/special/logit","base.lucas":"@stdlib/math/base/special/lucas","base.lucaspoly":"@stdlib/math/base/tools/lucaspoly","base.max":"@stdlib/math/base/special/max","base.maxabs":"@stdlib/math/base/special/maxabs","base.min":"@stdlib/math/base/special/min","base.minabs":"@stdlib/math/base/special/minabs","base.minmax":"@stdlib/math/base/special/minmax","base.minmaxabs":"@stdlib/math/base/special/minmaxabs","base.modf":"@stdlib/math/base/special/modf","base.ndarray":"@stdlib/ndarray/base/ctor","base.ndarrayMemoized":"@stdlib/ndarray/base/memoized-ctor","base.negafibonacci":"@stdlib/math/base/special/negafibonacci","base.negalucas":"@stdlib/math/base/special/negalucas","base.nonfibonacci":"@stdlib/math/base/special/nonfibonacci","base.normalize":"@stdlib/number/float64/base/normalize","base.normalizef":"@stdlib/number/float32/base/normalize","base.normhermitepoly":"@stdlib/math/base/tools/normhermitepoly","base.pdiff":"@stdlib/math/base/special/pdiff","base.polygamma":"@stdlib/math/base/special/polygamma","base.pow":"@stdlib/math/base/special/pow","base.powm1":"@stdlib/math/base/special/powm1","base.rad2deg":"@stdlib/math/base/special/rad2deg","base.ramp":"@stdlib/math/base/special/ramp","base.random.arcsine":"@stdlib/random/base/arcsine","base.random.bernoulli":"@stdlib/random/base/bernoulli","base.random.beta":"@stdlib/random/base/beta","base.random.betaprime":"@stdlib/random/base/betaprime","base.random.binomial":"@stdlib/random/base/binomial","base.random.boxMuller":"@stdlib/random/base/box-muller","base.random.cauchy":"@stdlib/random/base/cauchy","base.random.chi":"@stdlib/random/base/chi","base.random.chisquare":"@stdlib/random/base/chisquare","base.random.cosine":"@stdlib/random/base/cosine","base.random.discreteUniform":"@stdlib/random/base/discrete-uniform","base.random.erlang":"@stdlib/random/base/erlang","base.random.exponential":"@stdlib/random/base/exponential","base.random.f":"@stdlib/random/base/f","base.random.frechet":"@stdlib/random/base/frechet","base.random.gamma":"@stdlib/random/base/gamma","base.random.geometric":"@stdlib/random/base/geometric","base.random.gumbel":"@stdlib/random/base/gumbel","base.random.hypergeometric":"@stdlib/random/base/hypergeometric","base.random.improvedZiggurat":"@stdlib/random/base/improved-ziggurat","base.random.invgamma":"@stdlib/random/base/invgamma","base.random.kumaraswamy":"@stdlib/random/base/kumaraswamy","base.random.laplace":"@stdlib/random/base/laplace","base.random.levy":"@stdlib/random/base/levy","base.random.logistic":"@stdlib/random/base/logistic","base.random.lognormal":"@stdlib/random/base/lognormal","base.random.minstd":"@stdlib/random/base/minstd","base.random.minstdShuffle":"@stdlib/random/base/minstd-shuffle","base.random.mt19937":"@stdlib/random/base/mt19937","base.random.negativeBinomial":"@stdlib/random/base/negative-binomial","base.random.normal":"@stdlib/random/base/normal","base.random.pareto1":"@stdlib/random/base/pareto-type1","base.random.poisson":"@stdlib/random/base/poisson","base.random.randi":"@stdlib/random/base/randi","base.random.randn":"@stdlib/random/base/randn","base.random.randu":"@stdlib/random/base/randu","base.random.rayleigh":"@stdlib/random/base/rayleigh","base.random.t":"@stdlib/random/base/t","base.random.triangular":"@stdlib/random/base/triangular","base.random.uniform":"@stdlib/random/base/uniform","base.random.weibull":"@stdlib/random/base/weibull","base.reldiff":"@stdlib/math/base/utils/relative-difference","base.rempio2":"@stdlib/math/base/special/rempio2","base.risingFactorial":"@stdlib/math/base/special/rising-factorial","base.rotl32":"@stdlib/number/uint32/base/rotl","base.rotr32":"@stdlib/number/uint32/base/rotr","base.round":"@stdlib/math/base/special/round","base.round2":"@stdlib/math/base/special/round2","base.round10":"@stdlib/math/base/special/round10","base.roundb":"@stdlib/math/base/special/roundb","base.roundn":"@stdlib/math/base/special/roundn","base.roundsd":"@stdlib/math/base/special/roundsd","base.rsqrt":"@stdlib/math/base/special/rsqrt","base.sasum":"@stdlib/blas/base/sasum","base.saxpy":"@stdlib/blas/base/saxpy","base.scopy":"@stdlib/blas/base/scopy","base.setHighWord":"@stdlib/number/float64/base/set-high-word","base.setLowWord":"@stdlib/number/float64/base/set-low-word","base.sici":"@stdlib/math/base/special/sici","base.signbit":"@stdlib/number/float64/base/signbit","base.signbitf":"@stdlib/number/float32/base/signbit","base.significandf":"@stdlib/number/float32/base/significand","base.signum":"@stdlib/math/base/special/signum","base.sin":"@stdlib/math/base/special/sin","base.sinc":"@stdlib/math/base/special/sinc","base.sincos":"@stdlib/math/base/special/sincos","base.sincospi":"@stdlib/math/base/special/sincospi","base.sinh":"@stdlib/math/base/special/sinh","base.sinpi":"@stdlib/math/base/special/sinpi","base.spence":"@stdlib/math/base/special/spence","base.sqrt":"@stdlib/math/base/special/sqrt","base.sqrt1pm1":"@stdlib/math/base/special/sqrt1pm1","base.sumSeries":"@stdlib/math/base/tools/sum-series","base.tan":"@stdlib/math/base/special/tan","base.tanh":"@stdlib/math/base/special/tanh","base.toBinaryString":"@stdlib/number/float64/base/to-binary-string","base.toBinaryStringf":"@stdlib/number/float32/base/to-binary-string","base.toBinaryStringUint8":"@stdlib/number/uint8/base/to-binary-string","base.toBinaryStringUint16":"@stdlib/number/uint16/base/to-binary-string","base.toBinaryStringUint32":"@stdlib/number/uint32/base/to-binary-string","base.toWordf":"@stdlib/number/float32/base/to-word","base.toWords":"@stdlib/number/float64/base/to-words","base.trigamma":"@stdlib/math/base/special/trigamma","base.trunc":"@stdlib/math/base/special/trunc","base.trunc2":"@stdlib/math/base/special/trunc2","base.trunc10":"@stdlib/math/base/special/trunc10","base.truncb":"@stdlib/math/base/special/truncb","base.truncn":"@stdlib/math/base/special/truncn","base.truncsd":"@stdlib/math/base/special/truncsd","base.uimul":"@stdlib/math/base/special/uimul","base.uimuldw":"@stdlib/math/base/special/uimuldw","base.uint32ToInt32":"@stdlib/number/uint32/base/to-int32","base.vercos":"@stdlib/math/base/special/vercos","base.versin":"@stdlib/math/base/special/versin","base.wrap":"@stdlib/math/base/special/wrap","base.xlog1py":"@stdlib/math/base/special/xlog1py","base.xlogy":"@stdlib/math/base/special/xlogy","base.zeta":"@stdlib/math/base/special/riemann-zeta","BERNDT_CPS_WAGES_1985":"@stdlib/datasets/berndt-cps-wages-1985","bifurcate":"@stdlib/utils/bifurcate","bifurcateBy":"@stdlib/utils/bifurcate-by","bifurcateByAsync":"@stdlib/utils/async/bifurcate-by","bifurcateIn":"@stdlib/utils/bifurcate-in","bifurcateOwn":"@stdlib/utils/bifurcate-own","binomialTest":"@stdlib/stats/binomial-test","Buffer":"@stdlib/buffer/ctor","buffer2json":"@stdlib/buffer/to-json","capitalize":"@stdlib/string/capitalize","capitalizeKeys":"@stdlib/utils/capitalize-keys","CATALAN":"@stdlib/constants/math/float64-catalan","CBRT_EPS":"@stdlib/constants/math/float64-cbrt-eps","chdir":"@stdlib/process/chdir","chi2gof":"@stdlib/stats/chi2gof","circarray2iterator":"@stdlib/array/to-circular-iterator","circularArrayStream":"@stdlib/streams/node/from-circular-array","CircularBuffer":"@stdlib/utils/circular-buffer","CMUDICT":"@stdlib/datasets/cmudict","complex":"@stdlib/complex/cmplx","Complex64":"@stdlib/complex/float32","COMPLEX64_NUM_BYTES":"@stdlib/constants/math/complex64-num-bytes","Complex64Array":"@stdlib/array/complex64","Complex128":"@stdlib/complex/float64","COMPLEX128_NUM_BYTES":"@stdlib/constants/math/complex128-num-bytes","Complex128Array":"@stdlib/array/complex128","compose":"@stdlib/utils/compose","composeAsync":"@stdlib/utils/async/compose","configdir":"@stdlib/os/configdir","conj":"@stdlib/complex/conj","constantFunction":"@stdlib/utils/constant-function","constantStream":"@stdlib/streams/node/from-constant","constructorName":"@stdlib/utils/constructor-name","contains":"@stdlib/assert/contains","convertArray":"@stdlib/array/convert","convertArraySame":"@stdlib/array/convert-same","convertPath":"@stdlib/utils/convert-path","copy":"@stdlib/utils/copy","copyBuffer":"@stdlib/buffer/from-buffer","countBy":"@stdlib/utils/count-by","countByAsync":"@stdlib/utils/async/count-by","curry":"@stdlib/utils/curry","curryRight":"@stdlib/utils/curry-right","cwd":"@stdlib/process/cwd","DALE_CHALL_NEW":"@stdlib/datasets/dale-chall-new","datasets":"@stdlib/datasets","dayOfQuarter":"@stdlib/time/day-of-quarter","dayOfYear":"@stdlib/time/day-of-year","daysInMonth":"@stdlib/time/days-in-month","daysInYear":"@stdlib/time/days-in-year","debugSinkStream":"@stdlib/streams/node/debug-sink","debugStream":"@stdlib/streams/node/debug","deepEqual":"@stdlib/assert/deep-equal","deepGet":"@stdlib/utils/deep-get","deepHasOwnProp":"@stdlib/assert/deep-has-own-property","deepHasProp":"@stdlib/assert/deep-has-property","deepPluck":"@stdlib/utils/deep-pluck","deepSet":"@stdlib/utils/deep-set","defineMemoizedProperty":"@stdlib/utils/define-memoized-property","defineProperties":"@stdlib/utils/define-properties","defineProperty":"@stdlib/utils/define-property","dirname":"@stdlib/utils/dirname","DoublyLinkedList":"@stdlib/utils/doubly-linked-list","doUntil":"@stdlib/utils/do-until","doUntilAsync":"@stdlib/utils/async/do-until","doUntilEach":"@stdlib/utils/do-until-each","doUntilEachRight":"@stdlib/utils/do-until-each-right","doWhile":"@stdlib/utils/do-while","doWhileAsync":"@stdlib/utils/async/do-while","doWhileEach":"@stdlib/utils/do-while-each","doWhileEachRight":"@stdlib/utils/do-while-each-right","E":"@stdlib/constants/math/float64-e","emptyStream":"@stdlib/streams/node/empty","endsWith":"@stdlib/string/ends-with","enumerableProperties":"@stdlib/utils/enumerable-properties","enumerablePropertiesIn":"@stdlib/utils/enumerable-properties-in","enumerablePropertySymbols":"@stdlib/utils/enumerable-property-symbols","enumerablePropertySymbolsIn":"@stdlib/utils/enumerable-property-symbols-in","ENV":"@stdlib/process/env","EPS":"@stdlib/constants/math/float64-eps","error2json":"@stdlib/error/to-json","EULERGAMMA":"@stdlib/constants/math/float64-eulergamma","every":"@stdlib/utils/every","everyBy":"@stdlib/utils/every-by","everyByAsync":"@stdlib/utils/async/every-by","everyByRight":"@stdlib/utils/every-by-right","everyByRightAsync":"@stdlib/utils/async/every-by-right","evil":"@stdlib/utils/eval","exists":"@stdlib/fs/exists","expandContractions":"@stdlib/nlp/expand-contractions","extname":"@stdlib/utils/extname","fastmath.abs":"@stdlib/fastmath/special/abs","fastmath.acosh":"@stdlib/fastmath/special/acosh","fastmath.ampbm":"@stdlib/fastmath/special/alpha-max-plus-beta-min","fastmath.asinh":"@stdlib/fastmath/special/asinh","fastmath.atanh":"@stdlib/fastmath/special/atanh","fastmath.hypot":"@stdlib/fastmath/special/hypot","fastmath.log2Uint32":"@stdlib/fastmath/special/uint32-log2","fastmath.max":"@stdlib/fastmath/special/max","fastmath.min":"@stdlib/fastmath/special/min","fastmath.powint":"@stdlib/fastmath/special/pow-int","fastmath.sqrtUint32":"@stdlib/fastmath/special/uint32-sqrt","FEMALE_FIRST_NAMES_EN":"@stdlib/datasets/female-first-names-en","FIFO":"@stdlib/utils/fifo","find":"@stdlib/utils/find","flattenArray":"@stdlib/utils/flatten-array","flattenObject":"@stdlib/utils/flatten-object","flignerTest":"@stdlib/stats/fligner-test","FLOAT16_CBRT_EPS":"@stdlib/constants/math/float16-cbrt-eps","FLOAT16_EPS":"@stdlib/constants/math/float16-eps","FLOAT16_EXPONENT_BIAS":"@stdlib/constants/math/float16-exponent-bias","FLOAT16_MAX":"@stdlib/constants/math/float16-max","FLOAT16_MAX_SAFE_INTEGER":"@stdlib/constants/math/float16-max-safe-integer","FLOAT16_MIN_SAFE_INTEGER":"@stdlib/constants/math/float16-min-safe-integer","FLOAT16_NINF":"@stdlib/constants/math/float16-ninf","FLOAT16_NUM_BYTES":"@stdlib/constants/math/float16-num-bytes","FLOAT16_PINF":"@stdlib/constants/math/float16-pinf","FLOAT16_PRECISION":"@stdlib/constants/math/float16-precision","FLOAT16_SMALLEST_NORMAL":"@stdlib/constants/math/float16-smallest-normal","FLOAT16_SMALLEST_SUBNORMAL":"@stdlib/constants/math/float16-smallest-subnormal","FLOAT16_SQRT_EPS":"@stdlib/constants/math/float16-sqrt-eps","FLOAT32_CBRT_EPS":"@stdlib/constants/math/float32-cbrt-eps","FLOAT32_EPS":"@stdlib/constants/math/float32-eps","FLOAT32_EXPONENT_BIAS":"@stdlib/constants/math/float32-exponent-bias","FLOAT32_MAX":"@stdlib/constants/math/float32-max","FLOAT32_MAX_SAFE_INTEGER":"@stdlib/constants/math/float32-max-safe-integer","FLOAT32_MIN_SAFE_INTEGER":"@stdlib/constants/math/float32-min-safe-integer","FLOAT32_NINF":"@stdlib/constants/math/float32-ninf","FLOAT32_NUM_BYTES":"@stdlib/constants/math/float32-num-bytes","FLOAT32_PINF":"@stdlib/constants/math/float32-pinf","FLOAT32_PRECISION":"@stdlib/constants/math/float32-precision","FLOAT32_SMALLEST_NORMAL":"@stdlib/constants/math/float32-smallest-normal","FLOAT32_SMALLEST_SUBNORMAL":"@stdlib/constants/math/float32-smallest-subnormal","FLOAT32_SQRT_EPS":"@stdlib/constants/math/float32-sqrt-eps","Float32Array":"@stdlib/array/float32","FLOAT64_EXPONENT_BIAS":"@stdlib/constants/math/float64-exponent-bias","FLOAT64_HIGH_WORD_EXPONENT_MASK":"@stdlib/constants/math/float64-high-word-exponent-mask","FLOAT64_HIGH_WORD_SIGNIFICAND_MASK":"@stdlib/constants/math/float64-high-word-significand-mask","FLOAT64_MAX":"@stdlib/constants/math/float64-max","FLOAT64_MAX_BASE2_EXPONENT":"@stdlib/constants/math/float64-max-base2-exponent","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/math/float64-max-base2-exponent-subnormal","FLOAT64_MAX_BASE10_EXPONENT":"@stdlib/constants/math/float64-max-base10-exponent","FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/math/float64-max-base10-exponent-subnormal","FLOAT64_MAX_LN":"@stdlib/constants/math/float64-max-ln","FLOAT64_MAX_SAFE_FIBONACCI":"@stdlib/constants/math/float64-max-safe-fibonacci","FLOAT64_MAX_SAFE_INTEGER":"@stdlib/constants/math/float64-max-safe-integer","FLOAT64_MAX_SAFE_LUCAS":"@stdlib/constants/math/float64-max-safe-lucas","FLOAT64_MAX_SAFE_NTH_FIBONACCI":"@stdlib/constants/math/float64-max-safe-nth-fibonacci","FLOAT64_MAX_SAFE_NTH_LUCAS":"@stdlib/constants/math/float64-max-safe-nth-lucas","FLOAT64_MIN_BASE2_EXPONENT":"@stdlib/constants/math/float64-min-base2-exponent","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL":"@stdlib/constants/math/float64-min-base2-exponent-subnormal","FLOAT64_MIN_BASE10_EXPONENT":"@stdlib/constants/math/float64-min-base10-exponent","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL":"@stdlib/constants/math/float64-min-base10-exponent-subnormal","FLOAT64_MIN_LN":"@stdlib/constants/math/float64-min-ln","FLOAT64_MIN_SAFE_INTEGER":"@stdlib/constants/math/float64-min-safe-integer","FLOAT64_NUM_BYTES":"@stdlib/constants/math/float64-num-bytes","FLOAT64_PRECISION":"@stdlib/constants/math/float64-precision","FLOAT64_SMALLEST_NORMAL":"@stdlib/constants/math/float64-smallest-normal","FLOAT64_SMALLEST_SUBNORMAL":"@stdlib/constants/math/float64-smallest-subnormal","Float64Array":"@stdlib/array/float64","forEach":"@stdlib/utils/for-each","forEachAsync":"@stdlib/utils/async/for-each","forEachRight":"@stdlib/utils/for-each-right","forEachRightAsync":"@stdlib/utils/async/for-each-right","forIn":"@stdlib/utils/for-in","forOwn":"@stdlib/utils/for-own","FOURTH_PI":"@stdlib/constants/math/float64-fourth-pi","FOURTH_ROOT_EPS":"@stdlib/constants/math/float64-fourth-root-eps","FRB_SF_WAGE_RIGIDITY":"@stdlib/datasets/frb-sf-wage-rigidity","fromCodePoint":"@stdlib/string/from-code-point","functionName":"@stdlib/utils/function-name","functionSequence":"@stdlib/utils/function-sequence","functionSequenceAsync":"@stdlib/utils/async/function-sequence","GAMMA_LANCZOS_G":"@stdlib/constants/math/float64-gamma-lanczos-g","getegid":"@stdlib/process/getegid","geteuid":"@stdlib/process/geteuid","getgid":"@stdlib/process/getgid","getGlobal":"@stdlib/utils/global","getPrototypeOf":"@stdlib/utils/get-prototype-of","getuid":"@stdlib/process/getuid","GLAISHER":"@stdlib/constants/math/float64-glaisher-kinkelin","group":"@stdlib/utils/group","groupBy":"@stdlib/utils/group-by","groupByAsync":"@stdlib/utils/async/group-by","groupIn":"@stdlib/utils/group-in","groupOwn":"@stdlib/utils/group-own","HALF_LN2":"@stdlib/constants/math/float64-half-ln-two","HALF_PI":"@stdlib/constants/math/float64-half-pi","HARRISON_BOSTON_HOUSE_PRICES":"@stdlib/datasets/harrison-boston-house-prices","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED":"@stdlib/datasets/harrison-boston-house-prices-corrected","hasArrayBufferSupport":"@stdlib/assert/has-arraybuffer-support","hasAsyncAwaitSupport":"@stdlib/assert/has-async-await-support","hasAsyncIteratorSymbolSupport":"@stdlib/assert/has-async-iterator-symbol-support","hasClassSupport":"@stdlib/assert/has-class-support","hasDefinePropertiesSupport":"@stdlib/assert/has-define-properties-support","hasDefinePropertySupport":"@stdlib/assert/has-define-property-support","hasFloat32ArraySupport":"@stdlib/assert/has-float32array-support","hasFloat64ArraySupport":"@stdlib/assert/has-float64array-support","hasFunctionNameSupport":"@stdlib/assert/has-function-name-support","hasGeneratorSupport":"@stdlib/assert/has-generator-support","hasInt8ArraySupport":"@stdlib/assert/has-int8array-support","hasInt16ArraySupport":"@stdlib/assert/has-int16array-support","hasInt32ArraySupport":"@stdlib/assert/has-int32array-support","hasIteratorSymbolSupport":"@stdlib/assert/has-iterator-symbol-support","hasMapSupport":"@stdlib/assert/has-map-support","hasNodeBufferSupport":"@stdlib/assert/has-node-buffer-support","hasOwnProp":"@stdlib/assert/has-own-property","hasProp":"@stdlib/assert/has-property","hasProxySupport":"@stdlib/assert/has-proxy-support","hasSetSupport":"@stdlib/assert/has-set-support","hasSharedArrayBufferSupport":"@stdlib/assert/has-sharedarraybuffer-support","hasSymbolSupport":"@stdlib/assert/has-symbol-support","hasToStringTagSupport":"@stdlib/assert/has-tostringtag-support","hasUint8ArraySupport":"@stdlib/assert/has-uint8array-support","hasUint8ClampedArraySupport":"@stdlib/assert/has-uint8clampedarray-support","hasUint16ArraySupport":"@stdlib/assert/has-uint16array-support","hasUint32ArraySupport":"@stdlib/assert/has-uint32array-support","hasWeakMapSupport":"@stdlib/assert/has-weakmap-support","hasWeakSetSupport":"@stdlib/assert/has-weakset-support","hasWebAssemblySupport":"@stdlib/assert/has-wasm-support","HERNDON_VENUS_SEMIDIAMETERS":"@stdlib/datasets/herndon-venus-semidiameters","homedir":"@stdlib/os/homedir","HOURS_IN_DAY":"@stdlib/constants/time/hours-in-day","HOURS_IN_WEEK":"@stdlib/constants/time/hours-in-week","hoursInMonth":"@stdlib/time/hours-in-month","hoursInYear":"@stdlib/time/hours-in-year","httpServer":"@stdlib/net/http-server","identity":"@stdlib/utils/identity-function","ifelse":"@stdlib/utils/if-else","ifelseAsync":"@stdlib/utils/async/if-else","ifthen":"@stdlib/utils/if-then","ifthenAsync":"@stdlib/utils/async/if-then","imag":"@stdlib/complex/imag","IMG_ACANTHUS_MOLLIS":"@stdlib/datasets/img-acanthus-mollis","IMG_AIRPLANE_FROM_ABOVE":"@stdlib/datasets/img-airplane-from-above","IMG_ALLIUM_OREOPHILUM":"@stdlib/datasets/img-allium-oreophilum","IMG_BLACK_CANYON":"@stdlib/datasets/img-black-canyon","IMG_DUST_BOWL_HOME":"@stdlib/datasets/img-dust-bowl-home","IMG_FRENCH_ALPINE_LANDSCAPE":"@stdlib/datasets/img-french-alpine-landscape","IMG_LOCOMOTION_HOUSE_CAT":"@stdlib/datasets/img-locomotion-house-cat","IMG_LOCOMOTION_NUDE_MALE":"@stdlib/datasets/img-locomotion-nude-male","IMG_MARCH_PASTORAL":"@stdlib/datasets/img-march-pastoral","IMG_NAGASAKI_BOATS":"@stdlib/datasets/img-nagasaki-boats","incrapcorr":"@stdlib/stats/incr/apcorr","incrcount":"@stdlib/stats/incr/count","incrcovariance":"@stdlib/stats/incr/covariance","incrcovmat":"@stdlib/stats/incr/covmat","incrcv":"@stdlib/stats/incr/cv","increwmean":"@stdlib/stats/incr/ewmean","increwstdev":"@stdlib/stats/incr/ewstdev","increwvariance":"@stdlib/stats/incr/ewvariance","incrgmean":"@stdlib/stats/incr/gmean","incrgrubbs":"@stdlib/stats/incr/grubbs","incrhmean":"@stdlib/stats/incr/hmean","incrkmeans":"@stdlib/ml/incr/kmeans","incrkurtosis":"@stdlib/stats/incr/kurtosis","incrmaape":"@stdlib/stats/incr/maape","incrmae":"@stdlib/stats/incr/mae","incrmapcorr":"@stdlib/stats/incr/mapcorr","incrmape":"@stdlib/stats/incr/mape","incrmax":"@stdlib/stats/incr/max","incrmaxabs":"@stdlib/stats/incr/maxabs","incrmcovariance":"@stdlib/stats/incr/mcovariance","incrmcv":"@stdlib/stats/incr/mcv","incrmda":"@stdlib/stats/incr/mda","incrme":"@stdlib/stats/incr/me","incrmean":"@stdlib/stats/incr/mean","incrmeanabs":"@stdlib/stats/incr/meanabs","incrmeanabs2":"@stdlib/stats/incr/meanabs2","incrmeanstdev":"@stdlib/stats/incr/meanstdev","incrmeanvar":"@stdlib/stats/incr/meanvar","incrmgmean":"@stdlib/stats/incr/mgmean","incrmgrubbs":"@stdlib/stats/incr/mgrubbs","incrmhmean":"@stdlib/stats/incr/mhmean","incrmidrange":"@stdlib/stats/incr/midrange","incrmin":"@stdlib/stats/incr/min","incrminabs":"@stdlib/stats/incr/minabs","incrminmax":"@stdlib/stats/incr/minmax","incrminmaxabs":"@stdlib/stats/incr/minmaxabs","incrmmaape":"@stdlib/stats/incr/mmaape","incrmmae":"@stdlib/stats/incr/mmae","incrmmape":"@stdlib/stats/incr/mmape","incrmmax":"@stdlib/stats/incr/mmax","incrmmaxabs":"@stdlib/stats/incr/mmaxabs","incrmmda":"@stdlib/stats/incr/mmda","incrmme":"@stdlib/stats/incr/mme","incrmmean":"@stdlib/stats/incr/mmean","incrmmeanabs":"@stdlib/stats/incr/mmeanabs","incrmmeanabs2":"@stdlib/stats/incr/mmeanabs2","incrmmeanstdev":"@stdlib/stats/incr/mmeanstdev","incrmmeanvar":"@stdlib/stats/incr/mmeanvar","incrmmidrange":"@stdlib/stats/incr/mmidrange","incrmmin":"@stdlib/stats/incr/mmin","incrmminabs":"@stdlib/stats/incr/mminabs","incrmminmax":"@stdlib/stats/incr/mminmax","incrmminmaxabs":"@stdlib/stats/incr/mminmaxabs","incrmmpe":"@stdlib/stats/incr/mmpe","incrmmse":"@stdlib/stats/incr/mmse","incrmpcorr":"@stdlib/stats/incr/mpcorr","incrmpcorr2":"@stdlib/stats/incr/mpcorr2","incrmpcorrdist":"@stdlib/stats/incr/mpcorrdist","incrmpe":"@stdlib/stats/incr/mpe","incrmprod":"@stdlib/stats/incr/mprod","incrmrange":"@stdlib/stats/incr/mrange","incrmrmse":"@stdlib/stats/incr/mrmse","incrmrss":"@stdlib/stats/incr/mrss","incrmse":"@stdlib/stats/incr/mse","incrmstdev":"@stdlib/stats/incr/mstdev","incrmsum":"@stdlib/stats/incr/msum","incrmsumabs":"@stdlib/stats/incr/msumabs","incrmsumabs2":"@stdlib/stats/incr/msumabs2","incrmsummary":"@stdlib/stats/incr/msummary","incrmsumprod":"@stdlib/stats/incr/msumprod","incrmvariance":"@stdlib/stats/incr/mvariance","incrmvmr":"@stdlib/stats/incr/mvmr","incrpcorr":"@stdlib/stats/incr/pcorr","incrpcorr2":"@stdlib/stats/incr/pcorr2","incrpcorrdist":"@stdlib/stats/incr/pcorrdist","incrpcorrdistmat":"@stdlib/stats/incr/pcorrdistmat","incrpcorrmat":"@stdlib/stats/incr/pcorrmat","incrprod":"@stdlib/stats/incr/prod","incrrange":"@stdlib/stats/incr/range","incrrmse":"@stdlib/stats/incr/rmse","incrrss":"@stdlib/stats/incr/rss","incrskewness":"@stdlib/stats/incr/skewness","incrspace":"@stdlib/math/utils/incrspace","incrstdev":"@stdlib/stats/incr/stdev","incrsum":"@stdlib/stats/incr/sum","incrsumabs":"@stdlib/stats/incr/sumabs","incrsumabs2":"@stdlib/stats/incr/sumabs2","incrsummary":"@stdlib/stats/incr/summary","incrsumprod":"@stdlib/stats/incr/sumprod","incrvariance":"@stdlib/stats/incr/variance","incrvmr":"@stdlib/stats/incr/vmr","incrwmean":"@stdlib/stats/incr/wmean","ind2sub":"@stdlib/ndarray/ind2sub","indexOf":"@stdlib/utils/index-of","inherit":"@stdlib/utils/inherit","inheritedEnumerableProperties":"@stdlib/utils/inherited-enumerable-properties","inheritedEnumerablePropertySymbols":"@stdlib/utils/inherited-enumerable-property-symbols","inheritedKeys":"@stdlib/utils/inherited-keys","inheritedNonEnumerableProperties":"@stdlib/utils/inherited-nonenumerable-properties","inheritedNonEnumerablePropertyNames":"@stdlib/utils/inherited-nonenumerable-property-names","inheritedNonEnumerablePropertySymbols":"@stdlib/utils/inherited-nonenumerable-property-symbols","inheritedProperties":"@stdlib/utils/inherited-properties","inheritedPropertyDescriptor":"@stdlib/utils/inherited-property-descriptor","inheritedPropertyDescriptors":"@stdlib/utils/inherited-property-descriptors","inheritedPropertyNames":"@stdlib/utils/inherited-property-names","inheritedPropertySymbols":"@stdlib/utils/inherited-property-symbols","inheritedWritableProperties":"@stdlib/utils/inherited-writable-properties","inheritedWritablePropertyNames":"@stdlib/utils/inherited-writable-property-names","inheritedWritablePropertySymbols":"@stdlib/utils/inherited-writable-property-symbols","inmap":"@stdlib/utils/inmap","inmapAsync":"@stdlib/utils/async/inmap","inmapRight":"@stdlib/utils/inmap-right","inmapRightAsync":"@stdlib/utils/async/inmap-right","inspectSinkStream":"@stdlib/streams/node/inspect-sink","inspectStream":"@stdlib/streams/node/inspect","instanceOf":"@stdlib/assert/instance-of","INT8_MAX":"@stdlib/constants/math/int8-max","INT8_MIN":"@stdlib/constants/math/int8-min","INT8_NUM_BYTES":"@stdlib/constants/math/int8-num-bytes","Int8Array":"@stdlib/array/int8","INT16_MAX":"@stdlib/constants/math/int16-max","INT16_MIN":"@stdlib/constants/math/int16-min","INT16_NUM_BYTES":"@stdlib/constants/math/int16-num-bytes","Int16Array":"@stdlib/array/int16","INT32_MAX":"@stdlib/constants/math/int32-max","INT32_MIN":"@stdlib/constants/math/int32-min","INT32_NUM_BYTES":"@stdlib/constants/math/int32-num-bytes","Int32Array":"@stdlib/array/int32","IS_BIG_ENDIAN":"@stdlib/assert/is-big-endian","IS_BROWSER":"@stdlib/assert/is-browser","IS_DARWIN":"@stdlib/assert/is-darwin","IS_ELECTRON":"@stdlib/assert/is-electron","IS_ELECTRON_MAIN":"@stdlib/assert/is-electron-main","IS_ELECTRON_RENDERER":"@stdlib/assert/is-electron-renderer","IS_LITTLE_ENDIAN":"@stdlib/assert/is-little-endian","IS_NODE":"@stdlib/assert/is-node","IS_WEB_WORKER":"@stdlib/assert/is-web-worker","IS_WINDOWS":"@stdlib/assert/is-windows","isAbsolutePath":"@stdlib/assert/is-absolute-path","isAccessorProperty":"@stdlib/assert/is-accessor-property","isAccessorPropertyIn":"@stdlib/assert/is-accessor-property-in","isAlphagram":"@stdlib/assert/is-alphagram","isAlphaNumeric":"@stdlib/assert/is-alphanumeric","isAnagram":"@stdlib/assert/is-anagram","isArguments":"@stdlib/assert/is-arguments","isArray":"@stdlib/assert/is-array","isArrayArray":"@stdlib/assert/is-array-array","isArrayBuffer":"@stdlib/assert/is-arraybuffer","isArrayLength":"@stdlib/assert/is-array-length","isArrayLike":"@stdlib/assert/is-array-like","isArrayLikeObject":"@stdlib/assert/is-array-like-object","isASCII":"@stdlib/assert/is-ascii","isBetween":"@stdlib/assert/is-between","isBetweenArray":"@stdlib/assert/is-between-array","isBinaryString":"@stdlib/assert/is-binary-string","isBoolean":"@stdlib/assert/is-boolean","isBooleanArray":"@stdlib/assert/is-boolean-array","isBoxedPrimitive":"@stdlib/assert/is-boxed-primitive","isBuffer":"@stdlib/assert/is-buffer","isCapitalized":"@stdlib/assert/is-capitalized","isCentrosymmetricMatrix":"@stdlib/assert/is-centrosymmetric-matrix","isCircular":"@stdlib/assert/is-circular","isCircularArray":"@stdlib/assert/is-circular-array","isCircularPlainObject":"@stdlib/assert/is-circular-plain-object","isCollection":"@stdlib/assert/is-collection","isComplex":"@stdlib/assert/is-complex","isComplex64":"@stdlib/assert/is-complex64","isComplex64Array":"@stdlib/assert/is-complex64array","isComplex128":"@stdlib/assert/is-complex128","isComplex128Array":"@stdlib/assert/is-complex128array","isComplexLike":"@stdlib/assert/is-complex-like","isComplexTypedArray":"@stdlib/assert/is-complex-typed-array","isConfigurableProperty":"@stdlib/assert/is-configurable-property","isConfigurablePropertyIn":"@stdlib/assert/is-configurable-property-in","isDataProperty":"@stdlib/assert/is-data-property","isDataPropertyIn":"@stdlib/assert/is-data-property-in","isDateObject":"@stdlib/assert/is-date-object","isDigitString":"@stdlib/assert/is-digit-string","isEmailAddress":"@stdlib/assert/is-email-address","isEmptyArray":"@stdlib/assert/is-empty-array","isEmptyObject":"@stdlib/assert/is-empty-object","isEmptyString":"@stdlib/assert/is-empty-string","isEnumerableProperty":"@stdlib/assert/is-enumerable-property","isEnumerablePropertyIn":"@stdlib/assert/is-enumerable-property-in","isError":"@stdlib/assert/is-error","isEvalError":"@stdlib/assert/is-eval-error","isEven":"@stdlib/assert/is-even","isFalsy":"@stdlib/assert/is-falsy","isFalsyArray":"@stdlib/assert/is-falsy-array","isFinite":"@stdlib/assert/is-finite","isFiniteArray":"@stdlib/assert/is-finite-array","isFloat32Array":"@stdlib/assert/is-float32array","isFloat64Array":"@stdlib/assert/is-float64array","isFunction":"@stdlib/assert/is-function","isFunctionArray":"@stdlib/assert/is-function-array","isGeneratorObject":"@stdlib/assert/is-generator-object","isGeneratorObjectLike":"@stdlib/assert/is-generator-object-like","isHexString":"@stdlib/assert/is-hex-string","isInfinite":"@stdlib/assert/is-infinite","isInheritedProperty":"@stdlib/assert/is-inherited-property","isInt8Array":"@stdlib/assert/is-int8array","isInt16Array":"@stdlib/assert/is-int16array","isInt32Array":"@stdlib/assert/is-int32array","isInteger":"@stdlib/assert/is-integer","isIntegerArray":"@stdlib/assert/is-integer-array","isIterableLike":"@stdlib/assert/is-iterable-like","isIteratorLike":"@stdlib/assert/is-iterator-like","isJSON":"@stdlib/assert/is-json","isLeapYear":"@stdlib/assert/is-leap-year","isLowercase":"@stdlib/assert/is-lowercase","isMatrixLike":"@stdlib/assert/is-matrix-like","isMethod":"@stdlib/assert/is-method","isMethodIn":"@stdlib/assert/is-method-in","isNamedTypedTupleLike":"@stdlib/assert/is-named-typed-tuple-like","isnan":"@stdlib/assert/is-nan","isNaNArray":"@stdlib/assert/is-nan-array","isNativeFunction":"@stdlib/assert/is-native-function","isndarrayLike":"@stdlib/assert/is-ndarray-like","isNegativeInteger":"@stdlib/assert/is-negative-integer","isNegativeIntegerArray":"@stdlib/assert/is-negative-integer-array","isNegativeNumber":"@stdlib/assert/is-negative-number","isNegativeNumberArray":"@stdlib/assert/is-negative-number-array","isNegativeZero":"@stdlib/assert/is-negative-zero","isNodeBuiltin":"@stdlib/assert/is-node-builtin","isNodeDuplexStreamLike":"@stdlib/assert/is-node-duplex-stream-like","isNodeReadableStreamLike":"@stdlib/assert/is-node-readable-stream-like","isNodeREPL":"@stdlib/assert/is-node-repl","isNodeStreamLike":"@stdlib/assert/is-node-stream-like","isNodeTransformStreamLike":"@stdlib/assert/is-node-transform-stream-like","isNodeWritableStreamLike":"@stdlib/assert/is-node-writable-stream-like","isNonConfigurableProperty":"@stdlib/assert/is-nonconfigurable-property","isNonConfigurablePropertyIn":"@stdlib/assert/is-nonconfigurable-property-in","isNonEnumerableProperty":"@stdlib/assert/is-nonenumerable-property","isNonEnumerablePropertyIn":"@stdlib/assert/is-nonenumerable-property-in","isNonNegativeInteger":"@stdlib/assert/is-nonnegative-integer","isNonNegativeIntegerArray":"@stdlib/assert/is-nonnegative-integer-array","isNonNegativeNumber":"@stdlib/assert/is-nonnegative-number","isNonNegativeNumberArray":"@stdlib/assert/is-nonnegative-number-array","isNonPositiveInteger":"@stdlib/assert/is-nonpositive-integer","isNonPositiveIntegerArray":"@stdlib/assert/is-nonpositive-integer-array","isNonPositiveNumber":"@stdlib/assert/is-nonpositive-number","isNonPositiveNumberArray":"@stdlib/assert/is-nonpositive-number-array","isNonSymmetricMatrix":"@stdlib/assert/is-nonsymmetric-matrix","isNull":"@stdlib/assert/is-null","isNullArray":"@stdlib/assert/is-null-array","isNumber":"@stdlib/assert/is-number","isNumberArray":"@stdlib/assert/is-number-array","isNumericArray":"@stdlib/assert/is-numeric-array","isObject":"@stdlib/assert/is-object","isObjectArray":"@stdlib/assert/is-object-array","isObjectLike":"@stdlib/assert/is-object-like","isOdd":"@stdlib/assert/is-odd","isoWeeksInYear":"@stdlib/time/iso-weeks-in-year","isPersymmetricMatrix":"@stdlib/assert/is-persymmetric-matrix","isPlainObject":"@stdlib/assert/is-plain-object","isPlainObjectArray":"@stdlib/assert/is-plain-object-array","isPositiveInteger":"@stdlib/assert/is-positive-integer","isPositiveIntegerArray":"@stdlib/assert/is-positive-integer-array","isPositiveNumber":"@stdlib/assert/is-positive-number","isPositiveNumberArray":"@stdlib/assert/is-positive-number-array","isPositiveZero":"@stdlib/assert/is-positive-zero","isPrimitive":"@stdlib/assert/is-primitive","isPrimitiveArray":"@stdlib/assert/is-primitive-array","isPRNGLike":"@stdlib/assert/is-prng-like","isProbability":"@stdlib/assert/is-probability","isProbabilityArray":"@stdlib/assert/is-probability-array","isPrototypeOf":"@stdlib/assert/is-prototype-of","isRangeError":"@stdlib/assert/is-range-error","isReadableProperty":"@stdlib/assert/is-readable-property","isReadablePropertyIn":"@stdlib/assert/is-readable-property-in","isReadOnlyProperty":"@stdlib/assert/is-read-only-property","isReadOnlyPropertyIn":"@stdlib/assert/is-read-only-property-in","isReadWriteProperty":"@stdlib/assert/is-read-write-property","isReadWritePropertyIn":"@stdlib/assert/is-read-write-property-in","isReferenceError":"@stdlib/assert/is-reference-error","isRegExp":"@stdlib/assert/is-regexp","isRegExpString":"@stdlib/assert/is-regexp-string","isRelativePath":"@stdlib/assert/is-relative-path","isSafeInteger":"@stdlib/assert/is-safe-integer","isSafeIntegerArray":"@stdlib/assert/is-safe-integer-array","isSameValue":"@stdlib/assert/is-same-value","isSameValueZero":"@stdlib/assert/is-same-value-zero","isSharedArrayBuffer":"@stdlib/assert/is-sharedarraybuffer","isSkewCentrosymmetricMatrix":"@stdlib/assert/is-skew-centrosymmetric-matrix","isSkewPersymmetricMatrix":"@stdlib/assert/is-skew-persymmetric-matrix","isSkewSymmetricMatrix":"@stdlib/assert/is-skew-symmetric-matrix","isSquareMatrix":"@stdlib/assert/is-square-matrix","isStrictEqual":"@stdlib/assert/is-strict-equal","isString":"@stdlib/assert/is-string","isStringArray":"@stdlib/assert/is-string-array","isSymbol":"@stdlib/assert/is-symbol","isSymbolArray":"@stdlib/assert/is-symbol-array","isSymmetricMatrix":"@stdlib/assert/is-symmetric-matrix","isSyntaxError":"@stdlib/assert/is-syntax-error","isTruthy":"@stdlib/assert/is-truthy","isTruthyArray":"@stdlib/assert/is-truthy-array","isTypedArray":"@stdlib/assert/is-typed-array","isTypedArrayLength":"@stdlib/assert/is-typed-array-length","isTypedArrayLike":"@stdlib/assert/is-typed-array-like","isTypeError":"@stdlib/assert/is-type-error","isUint8Array":"@stdlib/assert/is-uint8array","isUint8ClampedArray":"@stdlib/assert/is-uint8clampedarray","isUint16Array":"@stdlib/assert/is-uint16array","isUint32Array":"@stdlib/assert/is-uint32array","isUNCPath":"@stdlib/assert/is-unc-path","isUndefined":"@stdlib/assert/is-undefined","isUndefinedOrNull":"@stdlib/assert/is-undefined-or-null","isUnityProbabilityArray":"@stdlib/assert/is-unity-probability-array","isUppercase":"@stdlib/assert/is-uppercase","isURI":"@stdlib/assert/is-uri","isURIError":"@stdlib/assert/is-uri-error","isVectorLike":"@stdlib/assert/is-vector-like","isWhitespace":"@stdlib/assert/is-whitespace","isWritableProperty":"@stdlib/assert/is-writable-property","isWritablePropertyIn":"@stdlib/assert/is-writable-property-in","isWriteOnlyProperty":"@stdlib/assert/is-write-only-property","isWriteOnlyPropertyIn":"@stdlib/assert/is-write-only-property-in","iterAdd":"@stdlib/math/iter/add","iterAdvance":"@stdlib/iter/advance","iterAny":"@stdlib/iter/any","iterAnyBy":"@stdlib/iter/any-by","iterator2array":"@stdlib/array/from-iterator","iterator2arrayview":"@stdlib/iter/to-array-view","iterator2arrayviewRight":"@stdlib/iter/to-array-view-right","iteratorStream":"@stdlib/streams/node/from-iterator","IteratorSymbol":"@stdlib/symbol/iterator","iterawgn":"@stdlib/simulate/iter/awgn","iterawln":"@stdlib/simulate/iter/awln","iterawun":"@stdlib/simulate/iter/awun","iterBartlettHannPulse":"@stdlib/simulate/iter/bartlett-hann-pulse","iterBartlettPulse":"@stdlib/simulate/iter/bartlett-pulse","iterConcat":"@stdlib/iter/concat","iterConstant":"@stdlib/iter/constant","iterCosineWave":"@stdlib/simulate/iter/cosine-wave","iterCounter":"@stdlib/iter/counter","itercugmean":"@stdlib/stats/iter/cugmean","itercuhmean":"@stdlib/stats/iter/cuhmean","itercumax":"@stdlib/stats/iter/cumax","itercumaxabs":"@stdlib/stats/iter/cumaxabs","itercumean":"@stdlib/stats/iter/cumean","itercumeanabs":"@stdlib/stats/iter/cumeanabs","itercumeanabs2":"@stdlib/stats/iter/cumeanabs2","itercumidrange":"@stdlib/stats/iter/cumidrange","itercumin":"@stdlib/stats/iter/cumin","itercuminabs":"@stdlib/stats/iter/cuminabs","itercuprod":"@stdlib/stats/iter/cuprod","itercurange":"@stdlib/stats/iter/curange","itercusum":"@stdlib/stats/iter/cusum","itercusumabs":"@stdlib/stats/iter/cusumabs","itercusumabs2":"@stdlib/stats/iter/cusumabs2","iterDedupe":"@stdlib/iter/dedupe","iterDedupeBy":"@stdlib/iter/dedupe-by","iterDiracComb":"@stdlib/simulate/iter/dirac-comb","iterDivide":"@stdlib/math/iter/divide","iterEmpty":"@stdlib/iter/empty","iterEvery":"@stdlib/iter/every","iterEveryBy":"@stdlib/iter/every-by","iterFibonacci":"@stdlib/math/iter/fibonacci","iterFill":"@stdlib/iter/fill","iterFilter":"@stdlib/iter/filter","iterFilterMap":"@stdlib/iter/filter-map","iterFirst":"@stdlib/iter/first","iterFlatTopPulse":"@stdlib/simulate/iter/flat-top-pulse","iterFlow":"@stdlib/iter/flow","iterForEach":"@stdlib/iter/for-each","iterHannPulse":"@stdlib/simulate/iter/hann-pulse","iterHead":"@stdlib/iter/head","iterIntersection":"@stdlib/iter/intersection","iterIntersectionByHash":"@stdlib/iter/intersection-by-hash","iterLanczosPulse":"@stdlib/simulate/iter/lanczos-pulse","iterLast":"@stdlib/iter/last","iterLength":"@stdlib/iter/length","iterMap":"@stdlib/iter/map","iterMapN":"@stdlib/iter/mapn","itermax":"@stdlib/stats/iter/max","itermaxabs":"@stdlib/stats/iter/maxabs","itermean":"@stdlib/stats/iter/mean","itermeanabs":"@stdlib/stats/iter/meanabs","itermeanabs2":"@stdlib/stats/iter/meanabs2","itermidrange":"@stdlib/stats/iter/midrange","itermin":"@stdlib/stats/iter/min","iterminabs":"@stdlib/stats/iter/minabs","itermmax":"@stdlib/stats/iter/mmax","itermmaxabs":"@stdlib/stats/iter/mmaxabs","itermmean":"@stdlib/stats/iter/mmean","itermmeanabs":"@stdlib/stats/iter/mmeanabs","itermmeanabs2":"@stdlib/stats/iter/mmeanabs2","itermmidrange":"@stdlib/stats/iter/mmidrange","itermmin":"@stdlib/stats/iter/mmin","itermminabs":"@stdlib/stats/iter/mminabs","iterMod":"@stdlib/math/iter/mod","itermprod":"@stdlib/stats/iter/mprod","itermrange":"@stdlib/stats/iter/mrange","itermsum":"@stdlib/stats/iter/msum","itermsumabs":"@stdlib/stats/iter/msumabs","itermsumabs2":"@stdlib/stats/iter/msumabs2","iterMultiply":"@stdlib/math/iter/multiply","iterNone":"@stdlib/iter/none","iterNoneBy":"@stdlib/iter/none-by","iterNonFibonacci":"@stdlib/math/iter/nonfibonacci","iterNth":"@stdlib/iter/nth","iterPeriodicSinc":"@stdlib/simulate/iter/periodic-sinc","iterPipeline":"@stdlib/iter/pipeline","iterPop":"@stdlib/iter/pop","iterprod":"@stdlib/stats/iter/prod","iterPulse":"@stdlib/simulate/iter/pulse","iterPush":"@stdlib/iter/push","iterrange":"@stdlib/stats/iter/range","iterReject":"@stdlib/iter/reject","iterReplicate":"@stdlib/iter/replicate","iterReplicateBy":"@stdlib/iter/replicate-by","iterSawtoothWave":"@stdlib/simulate/iter/sawtooth-wave","iterShift":"@stdlib/iter/shift","iterSineWave":"@stdlib/simulate/iter/sine-wave","iterSlice":"@stdlib/iter/slice","iterSome":"@stdlib/iter/some","iterSomeBy":"@stdlib/iter/some-by","iterSquareWave":"@stdlib/simulate/iter/square-wave","iterstdev":"@stdlib/stats/iter/stdev","iterSubtract":"@stdlib/math/iter/subtract","itersum":"@stdlib/stats/iter/sum","itersumabs":"@stdlib/stats/iter/sumabs","itersumabs2":"@stdlib/stats/iter/sumabs2","iterThunk":"@stdlib/iter/pipeline-thunk","iterTriangleWave":"@stdlib/simulate/iter/triangle-wave","iterUnion":"@stdlib/iter/union","iterUnique":"@stdlib/iter/unique","iterUniqueBy":"@stdlib/iter/unique-by","iterUniqueByHash":"@stdlib/iter/unique-by-hash","iterUnshift":"@stdlib/iter/unshift","itervariance":"@stdlib/stats/iter/variance","joinStream":"@stdlib/streams/node/join","kde2d":"@stdlib/stats/kde2d","keyBy":"@stdlib/utils/key-by","keyByRight":"@stdlib/utils/key-by-right","keysIn":"@stdlib/utils/keys-in","kruskalTest":"@stdlib/stats/kruskal-test","kstest":"@stdlib/stats/kstest","lda":"@stdlib/nlp/lda","LinkedList":"@stdlib/utils/linked-list","linspace":"@stdlib/math/utils/linspace","LIU_NEGATIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-negative-opinion-words-en","LIU_POSITIVE_OPINION_WORDS_EN":"@stdlib/datasets/liu-positive-opinion-words-en","LN_HALF":"@stdlib/constants/math/float64-ln-half","LN_PI":"@stdlib/constants/math/float64-ln-pi","LN_SQRT_TWO_PI":"@stdlib/constants/math/float64-ln-sqrt-two-pi","LN_TWO_PI":"@stdlib/constants/math/float64-ln-two-pi","LN2":"@stdlib/constants/math/float64-ln-two","LN10":"@stdlib/constants/math/float64-ln-ten","LOG2E":"@stdlib/constants/math/float64-log2-e","LOG10E":"@stdlib/constants/math/float64-log10-e","logspace":"@stdlib/math/utils/logspace","lowercase":"@stdlib/string/lowercase","lowercaseKeys":"@stdlib/utils/lowercase-keys","lowess":"@stdlib/stats/lowess","lpad":"@stdlib/string/left-pad","ltrim":"@stdlib/string/left-trim","MALE_FIRST_NAMES_EN":"@stdlib/datasets/male-first-names-en","mapFun":"@stdlib/utils/map-function","mapFunAsync":"@stdlib/utils/async/map-function","mapKeys":"@stdlib/utils/map-keys","mapKeysAsync":"@stdlib/utils/async/map-keys","mapValues":"@stdlib/utils/map-values","mapValuesAsync":"@stdlib/utils/async/map-values","MAX_ARRAY_LENGTH":"@stdlib/constants/array/max-array-length","MAX_TYPED_ARRAY_LENGTH":"@stdlib/constants/array/max-typed-array-length","memoize":"@stdlib/utils/memoize","merge":"@stdlib/utils/merge","MILLISECONDS_IN_DAY":"@stdlib/constants/time/milliseconds-in-day","MILLISECONDS_IN_HOUR":"@stdlib/constants/time/milliseconds-in-hour","MILLISECONDS_IN_MINUTE":"@stdlib/constants/time/milliseconds-in-minute","MILLISECONDS_IN_SECOND":"@stdlib/constants/time/milliseconds-in-second","MILLISECONDS_IN_WEEK":"@stdlib/constants/time/milliseconds-in-week","MINARD_NAPOLEONS_MARCH":"@stdlib/datasets/minard-napoleons-march","MINUTES_IN_DAY":"@stdlib/constants/time/minutes-in-day","MINUTES_IN_HOUR":"@stdlib/constants/time/minutes-in-hour","MINUTES_IN_WEEK":"@stdlib/constants/time/minutes-in-week","minutesInMonth":"@stdlib/time/minutes-in-month","minutesInYear":"@stdlib/time/minutes-in-year","MOBY_DICK":"@stdlib/datasets/moby-dick","MONTH_NAMES_EN":"@stdlib/datasets/month-names-en","MONTHS_IN_YEAR":"@stdlib/constants/time/months-in-year","moveProperty":"@stdlib/utils/move-property","namedtypedtuple":"@stdlib/utils/named-typed-tuple","nativeClass":"@stdlib/utils/native-class","ndarray":"@stdlib/ndarray/ctor","ndarrayCastingModes":"@stdlib/ndarray/casting-modes","ndarrayDataTypes":"@stdlib/ndarray/dtypes","ndarrayIndexModes":"@stdlib/ndarray/index-modes","ndarrayMemoized":"@stdlib/ndarray/memoized-ctor","ndarrayMinDataType":"@stdlib/ndarray/min-dtype","ndarrayNextDataType":"@stdlib/ndarray/next-dtype","ndarrayOrders":"@stdlib/ndarray/orders","ndarrayPromotionRules":"@stdlib/ndarray/promotion-rules","ndarraySafeCasts":"@stdlib/ndarray/safe-casts","ndarraySameKindCasts":"@stdlib/ndarray/same-kind-casts","NIGHTINGALES_ROSE":"@stdlib/datasets/nightingales-rose","NINF":"@stdlib/constants/math/float64-ninf","NODE_VERSION":"@stdlib/process/node-version","none":"@stdlib/utils/none","noneBy":"@stdlib/utils/none-by","noneByAsync":"@stdlib/utils/async/none-by","noneByRight":"@stdlib/utils/none-by-right","noneByRightAsync":"@stdlib/utils/async/none-by-right","nonEnumerableProperties":"@stdlib/utils/nonenumerable-properties","nonEnumerablePropertiesIn":"@stdlib/utils/nonenumerable-properties-in","nonEnumerablePropertyNames":"@stdlib/utils/nonenumerable-property-names","nonEnumerablePropertyNamesIn":"@stdlib/utils/nonenumerable-property-names-in","nonEnumerablePropertySymbols":"@stdlib/utils/nonenumerable-property-symbols","nonEnumerablePropertySymbolsIn":"@stdlib/utils/nonenumerable-property-symbols-in","noop":"@stdlib/utils/noop","now":"@stdlib/time/now","NUM_CPUS":"@stdlib/os/num-cpus","Number":"@stdlib/number/ctor","objectEntries":"@stdlib/utils/entries","objectEntriesIn":"@stdlib/utils/entries-in","objectFromEntries":"@stdlib/utils/from-entries","objectInverse":"@stdlib/utils/object-inverse","objectInverseBy":"@stdlib/utils/object-inverse-by","objectKeys":"@stdlib/utils/keys","objectValues":"@stdlib/utils/values","objectValuesIn":"@stdlib/utils/values-in","omit":"@stdlib/utils/omit","omitBy":"@stdlib/utils/omit-by","onlineBinaryClassification":"@stdlib/ml/online-binary-classification","onlineSGDRegression":"@stdlib/ml/online-sgd-regression","openURL":"@stdlib/utils/open-url","PACE_BOSTON_HOUSE_PRICES":"@stdlib/datasets/pace-boston-house-prices","pad":"@stdlib/string/pad","papply":"@stdlib/utils/papply","papplyRight":"@stdlib/utils/papply-right","parallel":"@stdlib/utils/parallel","parseJSON":"@stdlib/utils/parse-json","PATH_DELIMITER":"@stdlib/constants/string/path-delimiter","PATH_DELIMITER_POSIX":"@stdlib/constants/string/path-delimiter-posix","PATH_DELIMITER_WIN32":"@stdlib/constants/string/path-delimiter-win32","PATH_SEP":"@stdlib/constants/string/path-sep","PATH_SEP_POSIX":"@stdlib/constants/string/path-sep-posix","PATH_SEP_WIN32":"@stdlib/constants/string/path-sep-win32","pcorrtest":"@stdlib/stats/pcorrtest","percentEncode":"@stdlib/string/percent-encode","PHI":"@stdlib/constants/math/float64-phi","PI":"@stdlib/constants/math/float64-pi","PI_SQUARED":"@stdlib/constants/math/float64-pi-squared","pick":"@stdlib/utils/pick","pickBy":"@stdlib/utils/pick-by","PINF":"@stdlib/constants/math/float64-pinf","pkg2alias":"@stdlib/namespace/pkg2alias","pkg2related":"@stdlib/namespace/pkg2related","PLATFORM":"@stdlib/os/platform","plot":"@stdlib/plot","Plot":"@stdlib/plot/ctor","pluck":"@stdlib/utils/pluck","pop":"@stdlib/utils/pop","prepend":"@stdlib/utils/prepend","properties":"@stdlib/utils/properties","propertiesIn":"@stdlib/utils/properties-in","propertyDescriptor":"@stdlib/utils/property-descriptor","propertyDescriptorIn":"@stdlib/utils/property-descriptor-in","propertyDescriptors":"@stdlib/utils/property-descriptors","propertyDescriptorsIn":"@stdlib/utils/property-descriptors-in","propertyNames":"@stdlib/utils/property-names","propertyNamesIn":"@stdlib/utils/property-names-in","propertySymbols":"@stdlib/utils/property-symbols","propertySymbolsIn":"@stdlib/utils/property-symbols-in","Proxy":"@stdlib/proxy/ctor","push":"@stdlib/utils/push","quarterOfYear":"@stdlib/time/quarter-of-year","random.iterators.arcsine":"@stdlib/random/iter/arcsine","random.iterators.bernoulli":"@stdlib/random/iter/bernoulli","random.iterators.beta":"@stdlib/random/iter/beta","random.iterators.betaprime":"@stdlib/random/iter/betaprime","random.iterators.binomial":"@stdlib/random/iter/binomial","random.iterators.boxMuller":"@stdlib/random/iter/box-muller","random.iterators.cauchy":"@stdlib/random/iter/cauchy","random.iterators.chi":"@stdlib/random/iter/chi","random.iterators.chisquare":"@stdlib/random/iter/chisquare","random.iterators.cosine":"@stdlib/random/iter/cosine","random.iterators.discreteUniform":"@stdlib/random/iter/discrete-uniform","random.iterators.erlang":"@stdlib/random/iter/erlang","random.iterators.exponential":"@stdlib/random/iter/exponential","random.iterators.f":"@stdlib/random/iter/f","random.iterators.frechet":"@stdlib/random/iter/frechet","random.iterators.gamma":"@stdlib/random/iter/gamma","random.iterators.geometric":"@stdlib/random/iter/geometric","random.iterators.gumbel":"@stdlib/random/iter/gumbel","random.iterators.hypergeometric":"@stdlib/random/iter/hypergeometric","random.iterators.improvedZiggurat":"@stdlib/random/iter/improved-ziggurat","random.iterators.invgamma":"@stdlib/random/iter/invgamma","random.iterators.kumaraswamy":"@stdlib/random/iter/kumaraswamy","random.iterators.laplace":"@stdlib/random/iter/laplace","random.iterators.levy":"@stdlib/random/iter/levy","random.iterators.logistic":"@stdlib/random/iter/logistic","random.iterators.lognormal":"@stdlib/random/iter/lognormal","random.iterators.minstd":"@stdlib/random/iter/minstd","random.iterators.minstdShuffle":"@stdlib/random/iter/minstd-shuffle","random.iterators.mt19937":"@stdlib/random/iter/mt19937","random.iterators.negativeBinomial":"@stdlib/random/iter/negative-binomial","random.iterators.normal":"@stdlib/random/iter/normal","random.iterators.pareto1":"@stdlib/random/iter/pareto-type1","random.iterators.poisson":"@stdlib/random/iter/poisson","random.iterators.randi":"@stdlib/random/iter/randi","random.iterators.randn":"@stdlib/random/iter/randn","random.iterators.randu":"@stdlib/random/iter/randu","random.iterators.rayleigh":"@stdlib/random/iter/rayleigh","random.iterators.t":"@stdlib/random/iter/t","random.iterators.triangular":"@stdlib/random/iter/triangular","random.iterators.uniform":"@stdlib/random/iter/uniform","random.iterators.weibull":"@stdlib/random/iter/weibull","random.streams.arcsine":"@stdlib/random/streams/arcsine","random.streams.bernoulli":"@stdlib/random/streams/bernoulli","random.streams.beta":"@stdlib/random/streams/beta","random.streams.betaprime":"@stdlib/random/streams/betaprime","random.streams.binomial":"@stdlib/random/streams/binomial","random.streams.boxMuller":"@stdlib/random/streams/box-muller","random.streams.cauchy":"@stdlib/random/streams/cauchy","random.streams.chi":"@stdlib/random/streams/chi","random.streams.chisquare":"@stdlib/random/streams/chisquare","random.streams.cosine":"@stdlib/random/streams/cosine","random.streams.discreteUniform":"@stdlib/random/streams/discrete-uniform","random.streams.erlang":"@stdlib/random/streams/erlang","random.streams.exponential":"@stdlib/random/streams/exponential","random.streams.f":"@stdlib/random/streams/f","random.streams.gamma":"@stdlib/random/streams/gamma","random.streams.geometric":"@stdlib/random/streams/geometric","random.streams.gumbel":"@stdlib/random/streams/gumbel","random.streams.improvedZiggurat":"@stdlib/random/streams/improved-ziggurat","random.streams.invgamma":"@stdlib/random/streams/invgamma","random.streams.kumaraswamy":"@stdlib/random/streams/kumaraswamy","random.streams.laplace":"@stdlib/random/streams/laplace","random.streams.levy":"@stdlib/random/streams/levy","random.streams.logistic":"@stdlib/random/streams/logistic","random.streams.lognormal":"@stdlib/random/streams/lognormal","random.streams.minstd":"@stdlib/random/streams/minstd","random.streams.minstdShuffle":"@stdlib/random/streams/minstd-shuffle","random.streams.mt19937":"@stdlib/random/streams/mt19937","random.streams.negativeBinomial":"@stdlib/random/streams/negative-binomial","random.streams.normal":"@stdlib/random/streams/normal","random.streams.pareto1":"@stdlib/random/streams/pareto-type1","random.streams.poisson":"@stdlib/random/streams/poisson","random.streams.randi":"@stdlib/random/streams/randi","random.streams.randn":"@stdlib/random/streams/randn","random.streams.randu":"@stdlib/random/streams/randu","random.streams.rayleigh":"@stdlib/random/streams/rayleigh","random.streams.t":"@stdlib/random/streams/t","random.streams.uniform":"@stdlib/random/streams/uniform","random.streams.weibull":"@stdlib/random/streams/weibull","ranks":"@stdlib/stats/ranks","RE_BASENAME":"@stdlib/regexp/basename","RE_BASENAME_POSIX":"@stdlib/regexp/basename-posix","RE_BASENAME_WINDOWS":"@stdlib/regexp/basename-windows","RE_COLOR_HEXADECIMAL":"@stdlib/regexp/color-hexadecimal","RE_DECIMAL_NUMBER":"@stdlib/regexp/decimal-number","RE_DIRNAME":"@stdlib/regexp/dirname","RE_DIRNAME_POSIX":"@stdlib/regexp/dirname-posix","RE_DIRNAME_WINDOWS":"@stdlib/regexp/dirname-windows","RE_EOL":"@stdlib/regexp/eol","RE_EXTENDED_LENGTH_PATH":"@stdlib/regexp/extended-length-path","RE_EXTNAME":"@stdlib/regexp/extname","RE_EXTNAME_POSIX":"@stdlib/regexp/extname-posix","RE_EXTNAME_WINDOWS":"@stdlib/regexp/extname-windows","RE_FILENAME":"@stdlib/regexp/filename","RE_FILENAME_POSIX":"@stdlib/regexp/filename-posix","RE_FILENAME_WINDOWS":"@stdlib/regexp/filename-windows","RE_FUNCTION_NAME":"@stdlib/regexp/function-name","RE_NATIVE_FUNCTION":"@stdlib/regexp/native-function","RE_REGEXP":"@stdlib/regexp/regexp","RE_UNC_PATH":"@stdlib/regexp/unc-path","RE_UTF16_SURROGATE_PAIR":"@stdlib/regexp/utf16-surrogate-pair","RE_UTF16_UNPAIRED_SURROGATE":"@stdlib/regexp/utf16-unpaired-surrogate","RE_WHITESPACE":"@stdlib/regexp/whitespace","readDir":"@stdlib/fs/read-dir","readFile":"@stdlib/fs/read-file","readFileList":"@stdlib/fs/read-file-list","readJSON":"@stdlib/fs/read-json","readWASM":"@stdlib/fs/read-wasm","real":"@stdlib/complex/real","realmax":"@stdlib/utils/real-max","realmin":"@stdlib/utils/real-min","reduce":"@stdlib/utils/reduce","reduceAsync":"@stdlib/utils/async/reduce","reduceRight":"@stdlib/utils/reduce-right","reduceRightAsync":"@stdlib/utils/async/reduce-right","reFromString":"@stdlib/utils/regexp-from-string","reim":"@stdlib/complex/reim","removeFirst":"@stdlib/string/remove-first","removeLast":"@stdlib/string/remove-last","removePunctuation":"@stdlib/string/remove-punctuation","removeUTF8BOM":"@stdlib/string/remove-utf8-bom","removeWords":"@stdlib/string/remove-words","rename":"@stdlib/fs/rename","reorderArguments":"@stdlib/utils/reorder-arguments","repeat":"@stdlib/string/repeat","replace":"@stdlib/string/replace","rescape":"@stdlib/utils/escape-regexp-string","resolveParentPath":"@stdlib/fs/resolve-parent-path","reverseArguments":"@stdlib/utils/reverse-arguments","reverseString":"@stdlib/string/reverse","reviveBasePRNG":"@stdlib/random/base/reviver","reviveBuffer":"@stdlib/buffer/reviver","reviveComplex":"@stdlib/complex/reviver","reviveComplex64":"@stdlib/complex/reviver-float32","reviveComplex128":"@stdlib/complex/reviver-float64","reviveError":"@stdlib/error/reviver","reviveTypedArray":"@stdlib/array/reviver","rpad":"@stdlib/string/right-pad","rtrim":"@stdlib/string/right-trim","safeintmax":"@stdlib/utils/safe-int-max","safeintmin":"@stdlib/utils/safe-int-min","sample":"@stdlib/random/sample","SAVOY_STOPWORDS_FIN":"@stdlib/datasets/savoy-stopwords-fin","SAVOY_STOPWORDS_FR":"@stdlib/datasets/savoy-stopwords-fr","SAVOY_STOPWORDS_GER":"@stdlib/datasets/savoy-stopwords-ger","SAVOY_STOPWORDS_IT":"@stdlib/datasets/savoy-stopwords-it","SAVOY_STOPWORDS_POR":"@stdlib/datasets/savoy-stopwords-por","SAVOY_STOPWORDS_SP":"@stdlib/datasets/savoy-stopwords-sp","SAVOY_STOPWORDS_SWE":"@stdlib/datasets/savoy-stopwords-swe","SECONDS_IN_DAY":"@stdlib/constants/time/seconds-in-day","SECONDS_IN_HOUR":"@stdlib/constants/time/seconds-in-hour","SECONDS_IN_MINUTE":"@stdlib/constants/time/seconds-in-minute","SECONDS_IN_WEEK":"@stdlib/constants/time/seconds-in-week","secondsInMonth":"@stdlib/time/seconds-in-month","secondsInYear":"@stdlib/time/seconds-in-year","setConfigurableReadOnly":"@stdlib/utils/define-configurable-read-only-property","setConfigurableReadOnlyAccessor":"@stdlib/utils/define-configurable-read-only-accessor","setConfigurableReadWriteAccessor":"@stdlib/utils/define-configurable-read-write-accessor","setConfigurableWriteOnlyAccessor":"@stdlib/utils/define-configurable-write-only-accessor","setMemoizedReadOnly":"@stdlib/utils/define-memoized-read-only-property","setNonEnumerableProperty":"@stdlib/utils/define-nonenumerable-property","setNonEnumerableReadOnly":"@stdlib/utils/define-nonenumerable-read-only-property","setNonEnumerableReadOnlyAccessor":"@stdlib/utils/define-nonenumerable-read-only-accessor","setNonEnumerableReadWriteAccessor":"@stdlib/utils/define-nonenumerable-read-write-accessor","setNonEnumerableWriteOnlyAccessor":"@stdlib/utils/define-nonenumerable-write-only-accessor","setReadOnly":"@stdlib/utils/define-read-only-property","setReadOnlyAccessor":"@stdlib/utils/define-read-only-accessor","setReadWriteAccessor":"@stdlib/utils/define-read-write-accessor","setWriteOnlyAccessor":"@stdlib/utils/define-write-only-accessor","SharedArrayBuffer":"@stdlib/array/shared-buffer","shift":"@stdlib/utils/shift","shuffle":"@stdlib/random/shuffle","sizeOf":"@stdlib/utils/size-of","some":"@stdlib/utils/some","someBy":"@stdlib/utils/some-by","someByAsync":"@stdlib/utils/async/some-by","someByRight":"@stdlib/utils/some-by-right","someByRightAsync":"@stdlib/utils/async/some-by-right","SOTU":"@stdlib/datasets/sotu","SPACHE_REVISED":"@stdlib/datasets/spache-revised","SPAM_ASSASSIN":"@stdlib/datasets/spam-assassin","SparklineBase":"@stdlib/plot/sparklines/base/ctor","sparsearray2iterator":"@stdlib/array/to-sparse-iterator","sparsearray2iteratorRight":"@stdlib/array/to-sparse-iterator-right","splitStream":"@stdlib/streams/node/split","SQRT_EPS":"@stdlib/constants/math/float64-sqrt-eps","SQRT_HALF":"@stdlib/constants/math/float64-sqrt-half","SQRT_HALF_PI":"@stdlib/constants/math/float64-sqrt-half-pi","SQRT_PHI":"@stdlib/constants/math/float64-sqrt-phi","SQRT_PI":"@stdlib/constants/math/float64-sqrt-pi","SQRT_THREE":"@stdlib/constants/math/float64-sqrt-three","SQRT_TWO":"@stdlib/constants/math/float64-sqrt-two","SQRT_TWO_PI":"@stdlib/constants/math/float64-sqrt-two-pi","Stack":"@stdlib/utils/stack","startcase":"@stdlib/string/startcase","startsWith":"@stdlib/string/starts-with","STOPWORDS_EN":"@stdlib/datasets/stopwords-en","stridedarray2iterator":"@stdlib/array/to-strided-iterator","stridedArrayStream":"@stdlib/streams/node/from-strided-array","string2buffer":"@stdlib/buffer/from-string","sub2ind":"@stdlib/ndarray/sub2ind","SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-multi-hop-sensor-network","SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK":"@stdlib/datasets/suthaharan-single-hop-sensor-network","Symbol":"@stdlib/symbol/ctor","tabulate":"@stdlib/utils/tabulate","tabulateBy":"@stdlib/utils/tabulate-by","tabulateByAsync":"@stdlib/utils/async/tabulate-by","tic":"@stdlib/time/tic","timeit":"@stdlib/utils/timeit","tmpdir":"@stdlib/os/tmpdir","toc":"@stdlib/time/toc","tokenize":"@stdlib/nlp/tokenize","transformStream":"@stdlib/streams/node/transform","trim":"@stdlib/string/trim","trycatch":"@stdlib/utils/try-catch","trycatchAsync":"@stdlib/utils/async/try-catch","tryFunction":"@stdlib/utils/try-function","tryRequire":"@stdlib/utils/try-require","trythen":"@stdlib/utils/try-then","trythenAsync":"@stdlib/utils/async/try-then","ttest":"@stdlib/stats/ttest","ttest2":"@stdlib/stats/ttest2","TWO_PI":"@stdlib/constants/math/float64-two-pi","typedarray":"@stdlib/array/typed","typedarray2json":"@stdlib/array/to-json","typedarrayComplexCtors":"@stdlib/array/typed-complex-ctors","typedarrayComplexDataTypes":"@stdlib/array/typed-complex-dtypes","typedarrayCtors":"@stdlib/array/typed-ctors","typedarrayDataTypes":"@stdlib/array/typed-dtypes","typedarraypool":"@stdlib/array/pool","typemax":"@stdlib/utils/type-max","typemin":"@stdlib/utils/type-min","typeOf":"@stdlib/utils/type-of","UINT8_MAX":"@stdlib/constants/math/uint8-max","UINT8_NUM_BYTES":"@stdlib/constants/math/uint8-num-bytes","Uint8Array":"@stdlib/array/uint8","Uint8ClampedArray":"@stdlib/array/uint8c","UINT16_MAX":"@stdlib/constants/math/uint16-max","UINT16_NUM_BYTES":"@stdlib/constants/math/uint16-num-bytes","Uint16Array":"@stdlib/array/uint16","UINT32_MAX":"@stdlib/constants/math/uint32-max","UINT32_NUM_BYTES":"@stdlib/constants/math/uint32-num-bytes","Uint32Array":"@stdlib/array/uint32","umask":"@stdlib/process/umask","uncapitalize":"@stdlib/string/uncapitalize","uncapitalizeKeys":"@stdlib/utils/uncapitalize-keys","uncurry":"@stdlib/utils/uncurry","uncurryRight":"@stdlib/utils/uncurry-right","UNICODE_MAX":"@stdlib/constants/string/unicode-max","UNICODE_MAX_BMP":"@stdlib/constants/string/unicode-max-bmp","UnicodeColumnChartSparkline":"@stdlib/plot/sparklines/unicode/column","UnicodeLineChartSparkline":"@stdlib/plot/sparklines/unicode/line","UnicodeSparkline":"@stdlib/plot/sparklines/unicode","UnicodeTristateChartSparkline":"@stdlib/plot/sparklines/unicode/tristate","UnicodeUpDownChartSparkline":"@stdlib/plot/sparklines/unicode/up-down","UnicodeWinLossChartSparkline":"@stdlib/plot/sparklines/unicode/win-loss","unlink":"@stdlib/fs/unlink","unshift":"@stdlib/utils/unshift","until":"@stdlib/utils/until","untilAsync":"@stdlib/utils/async/until","untilEach":"@stdlib/utils/until-each","untilEachRight":"@stdlib/utils/until-each-right","unzip":"@stdlib/utils/unzip","uppercase":"@stdlib/string/uppercase","uppercaseKeys":"@stdlib/utils/uppercase-keys","US_STATES_ABBR":"@stdlib/datasets/us-states-abbr","US_STATES_CAPITALS":"@stdlib/datasets/us-states-capitals","US_STATES_CAPITALS_NAMES":"@stdlib/datasets/us-states-capitals-names","US_STATES_NAMES":"@stdlib/datasets/us-states-names","US_STATES_NAMES_CAPITALS":"@stdlib/datasets/us-states-names-capitals","utf16ToUTF8Array":"@stdlib/string/utf16-to-utf8-array","vartest":"@stdlib/stats/vartest","waterfall":"@stdlib/utils/async/series-waterfall","whileAsync":"@stdlib/utils/async/while","whileEach":"@stdlib/utils/while-each","whileEachRight":"@stdlib/utils/while-each-right","whilst":"@stdlib/utils/while","writableProperties":"@stdlib/utils/writable-properties","writablePropertiesIn":"@stdlib/utils/writable-properties-in","writablePropertyNames":"@stdlib/utils/writable-property-names","writablePropertyNamesIn":"@stdlib/utils/writable-property-names-in","writablePropertySymbols":"@stdlib/utils/writable-property-symbols","writablePropertySymbolsIn":"@stdlib/utils/writable-property-symbols-in","writeFile":"@stdlib/fs/write-file","zip":"@stdlib/utils/zip","ztest":"@stdlib/stats/ztest","ztest2":"@stdlib/stats/ztest2"}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/datapackage.json b/lib/node_modules/@stdlib/namespace/alias2pkg/datapackage.json
new file mode 100644
index 000000000000..740ee9820ba5
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/datapackage.json
@@ -0,0 +1,56 @@
+{
+ "name": "stdlib-alias2pkg",
+ "version": "",
+ "title": "Standard Library Aliases and Package Names",
+ "description": "A mapping between standard library aliases and package names.",
+ "resources": [
+ {
+ "name": "stdlib-alias2pkg-json",
+ "title": "Standard Library Aliases and Package Names",
+ "description": "A mapping between standard library aliases and package names.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-alias2pkg-csv",
+ "title": "Standard Library Aliases and Package Names",
+ "description": "A mapping between standard library aliases and package names.",
+ "format": "csv",
+ "mediatype": "plain/csv",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.csv",
+ "schema": {
+ "fields": [
+ {
+ "name": "alias",
+ "title": "Alias",
+ "description": "Alias.",
+ "type": "string",
+ "format": "default"
+ },
+ {
+ "name": "pkg",
+ "title": "Package Name",
+ "description": "Package name.",
+ "type": "string",
+ "format": "default"
+ }
+ ]
+ }
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "stdlib",
+ "namespace",
+ "aliases",
+ "package",
+ "name",
+ "pkg"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/docs/repl.txt b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/repl.txt
new file mode 100644
index 000000000000..635a89856808
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/repl.txt
@@ -0,0 +1,22 @@
+
+{{alias}}( alias )
+ Returns the package name associated with a provided alias.
+
+ Parameters
+ ----------
+ alias: string
+ Alias.
+
+ Returns
+ -------
+ out: string|null
+ Package name.
+
+ Examples
+ --------
+ > var v = {{alias}}( '{{alias:@stdlib/math/base/special/sin}}' )
+ '@stdlib/math/base/special/sin'
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/index.d.ts b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/index.d.ts
new file mode 100644
index 000000000000..d15290806ca3
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/index.d.ts
@@ -0,0 +1,36 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns a package name associated with a specified alias.
+*
+* @param alias - alias
+* @returns package name
+*
+* @example
+* var v = alias2pkg( 'base.sin' );
+* // returns '@stdlib/math/base/special/sin'
+*/
+declare function alias2pkg( alias: string ): string | null;
+
+
+// EXPORTS //
+
+export = alias2pkg;
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/test.ts b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/test.ts
new file mode 100644
index 000000000000..a3148c28cc16
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 alias2pkg = require( './index' );
+
+
+// TESTS //
+
+// The function returns a string or null...
+{
+ alias2pkg( 'base.sin' ); // $ExpectType string | null
+}
+
+// The compiler throws an error if the function is not provided a string...
+{
+ alias2pkg( 5 ); // $ExpectError
+ alias2pkg( true ); // $ExpectError
+ alias2pkg( false ); // $ExpectError
+ alias2pkg( null ); // $ExpectError
+ alias2pkg( undefined ); // $ExpectError
+ alias2pkg( [] ); // $ExpectError
+ alias2pkg( {} ); // $ExpectError
+ alias2pkg( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ alias2pkg( 'base.sin', 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/docs/usage.txt b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/usage.txt
new file mode 100644
index 000000000000..cfb5b141ec97
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-alias2pkg [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/etc/cli_opts.json b/lib/node_modules/@stdlib/namespace/alias2pkg/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/examples/index.js b/lib/node_modules/@stdlib/namespace/alias2pkg/examples/index.js
new file mode 100644
index 000000000000..5b097c603503
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/examples/index.js
@@ -0,0 +1,38 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( './../lib' );
+
+var list;
+var len;
+var idx;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ console.log( 'alias: %s. pkg: %s.', v, alias2pkg( v ) );
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/lib/index.js b/lib/node_modules/@stdlib/namespace/alias2pkg/lib/index.js
new file mode 100644
index 000000000000..df97f6503048
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/lib/index.js
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 the package name associated with a specified alias.
+*
+* @module @stdlib/namespace/alias2pkg
+*
+* @example
+* var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+*
+* var v = alias2pkg( 'base.sin' );
+* // returns '@stdlib/math/base/special/sin'
+*/
+
+// MODULES //
+
+var alias2pkg = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = alias2pkg;
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/lib/main.js b/lib/node_modules/@stdlib/namespace/alias2pkg/lib/main.js
new file mode 100644
index 000000000000..911b0b8c4b3a
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/lib/main.js
@@ -0,0 +1,54 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var ALIAS_TO_PKG = require( './../data/data.json' );
+
+
+// MAIN //
+
+/**
+* Returns the package name associated with a specified alias.
+*
+* @param {string} alias - alias
+* @throws {TypeError} must provide a string
+* @returns {(string|null)} package name
+*
+* @example
+* var v = alias2pkg( 'base.sin' );
+* // returns '@stdlib/math/base/special/sin'
+*/
+function alias2pkg( alias ) {
+ if ( !isString( alias ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + alias + '`.' );
+ }
+ if ( hasOwnProp( ALIAS_TO_PKG, alias ) ) {
+ return ALIAS_TO_PKG[ alias ];
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = alias2pkg;
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/package.json b/lib/node_modules/@stdlib/namespace/alias2pkg/package.json
new file mode 100644
index 000000000000..b6f5fa9029a2
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/package.json
@@ -0,0 +1,68 @@
+{
+ "name": "@stdlib/namespace/alias2pkg",
+ "version": "0.0.0",
+ "description": "Return the package name associated with a specified alias.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-alias2pkg": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "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",
+ "standard",
+ "library",
+ "lib",
+ "aliases",
+ "alias",
+ "namespace",
+ "package",
+ "name",
+ "pkg"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/scripts/build.js b/lib/node_modules/@stdlib/namespace/alias2pkg/scripts/build.js
new file mode 100644
index 000000000000..c9653f168c9c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/scripts/build.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var namespace = require( '@stdlib/namespace' );
+var objectKeys = require( '@stdlib/utils/keys' );
+
+
+// VARIABLES //
+
+var debug = logger( 'namespace:alias2pkg:build' );
+
+// Output file paths:
+var OUTPUT_JSON = resolve( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_CSV = resolve( __dirname, '..', 'data', 'data.csv' );
+
+
+// FUNCTIONS //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var fopts;
+ var keys;
+ var json;
+ var csv;
+ var ns;
+ var i;
+
+ debug( 'Extracting namespace aliases and package names...' );
+ ns = namespace();
+ json = {};
+ for ( i = 0; i < ns.length; i++ ) {
+ json[ ns[i].alias ] = ns[ i ].path;
+ }
+
+ debug( 'Writing to JSON file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_JSON, JSON.stringify( json ), fopts );
+
+ debug( 'Writing to CSV file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ keys = objectKeys( json );
+ csv = '';
+ for ( i = 0; i < keys.length; i++ ) {
+ csv += keys[ i ] + ',"' + json[ keys[i] ] + '"\n'; // Note: ensures trailing newline
+ }
+ writeFile( OUTPUT_CSV, csv, fopts );
+}
+
+
+// MAIN //
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.cli.js b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.cli.js
new file mode 100644
index 000000000000..dec567371a76
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.cli.js
@@ -0,0 +1,181 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints a package name', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'base.sin'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '@stdlib/math/base/special/sin\n', 'prints expected value' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
+
+tape( 'if unable to resolve a package name, the command-line interface sets a non-zero exit code', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'fjaldfjadljfeoejreandfljasdfjadsfjs'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.pass( error.message );
+ t.strictEqual( error.code, 1, 'expected exit code' );
+ }
+ t.strictEqual( stdout.toString(), '', 'does not print to` stdout`' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js
new file mode 100644
index 000000000000..fe16e00e63f9
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2pkg/test/test.js
@@ -0,0 +1,93 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( '@stdlib/namespace/aliases' );
+var DATA = require( './../data/data.json' );
+var alias2pkg = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof alias2pkg, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a string', function test( t ) {
+ var values;
+ 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() {
+ alias2pkg( value );
+ };
+ }
+});
+
+tape( 'the function returns a package name', function test( t ) {
+ var expected;
+ var actual;
+ var list;
+ var i;
+
+ list = aliases();
+ for ( i = 0; i < list.length; i++ ) {
+ expected = DATA[ list[i] ];
+ actual = alias2pkg( list[i] );
+ t.strictEqual( typeof actual, 'string', 'returns a string' );
+ t.strictEqual( actual, expected, 'returns expected value for '+list[i] );
+ }
+ t.end();
+});
+
+tape( 'the function returns `null` if provided an unrecognized alias', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ 'adfkaljdfdsafs',
+ 'adklfadjflajdslfjalsdf',
+ 'adflkajdlkfjasdlkfjsadlkfjlasdjflsdjfla'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.strictEqual( alias2pkg( values[ i ] ), null, 'returns expected value' );
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/LICENSE b/lib/node_modules/@stdlib/namespace/alias2related/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/README.md b/lib/node_modules/@stdlib/namespace/alias2related/README.md
new file mode 100644
index 000000000000..0152e8fb0f6c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/README.md
@@ -0,0 +1,187 @@
+
+
+# alias2related
+
+> Return aliases related to a specified alias.
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var alias2related = require( '@stdlib/namespace/alias2related' );
+```
+
+#### alias2related( alias )
+
+Returns aliases related to a specified `alias`.
+
+```javascript
+var out = alias2related( 'base.sin' );
+// returns [...]
+```
+
+If provided an unrecognized `alias`, the function returns `null`.
+
+```javascript
+var out = alias2related( 'unrecognized_alias_beep_boop_bop_bip' );
+// returns null
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2related = require( '@stdlib/namespace/alias2related' );
+
+var list;
+var len;
+var idx;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ console.log( 'alias: %s. related: %s.', v, alias2related( v ).join( ', ' ) );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-alias2related [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-alias2related 'base.sin'
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/benchmark/benchmark.js b/lib/node_modules/@stdlib/namespace/alias2related/benchmark/benchmark.js
new file mode 100644
index 000000000000..e24504d6b75c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/benchmark/benchmark.js
@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isStringArray = require( '@stdlib/assert/is-string-array' ).primitives;
+var aliases = require( '@stdlib/namespace/aliases' );
+var pkg = require( './../package.json' ).name;
+var alias2related = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = aliases();
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = alias2related( values[ i%values.length ] );
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( v.length > 0 && !isStringArray( v ) ) {
+ b.fail( 'should return an array of strings' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/bin/cli b/lib/node_modules/@stdlib/namespace/alias2related/bin/cli
new file mode 100755
index 000000000000..41c8a7df70a4
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/bin/cli
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var alias2related = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Resolve related aliases...
+ out = alias2related( args[ 0 ] );
+ if ( out ) {
+ if ( out.length ) {
+ console.log( out.join( '\n' ) ); // eslint-disable-line no-console
+ }
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/data/data.csv b/lib/node_modules/@stdlib/namespace/alias2related/data/data.csv
new file mode 100644
index 000000000000..7f7cf6d0dfd4
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/data/data.csv
@@ -0,0 +1,1894 @@
+AFINN_96,"AFINN_111"
+AFINN_111,"AFINN_96"
+alias2pkg,"alias2related,aliases,pkg2alias"
+alias2related,"alias2pkg,aliases,pkg2related"
+aliases,"alias2pkg,alias2related,pkg2alias"
+allocUnsafe,"Buffer,array2buffer,arraybuffer2buffer,copyBuffer,string2buffer"
+anova1,""
+ANSCOMBES_QUARTET,""
+any,"anyBy,every,forEach,none,some"
+anyBy,"anyByAsync,anyByRight,everyBy,forEach,noneBy,someBy"
+anyByAsync,"anyBy,anyByRightAsync,everyByAsync,forEachAsync,noneByAsync,someByAsync"
+anyByRight,"anyBy,anyByRightAsync,everyByRight,forEachRight,noneByRight,someByRight"
+anyByRightAsync,"anyByAsync,anyByRight,everyByRightAsync,forEachRightAsync,noneByRightAsync,someByRightAsync"
+APERY,""
+append,"prepend,push"
+ARCH,"PLATFORM"
+argumentFunction,"constantFunction,identity"
+ARGV,"ENV"
+array,"ndarray"
+array2buffer,"Buffer,arraybuffer2buffer,copyBuffer,string2buffer"
+array2iterator,"iterator2array,circarray2iterator,array2iteratorRight,stridedarray2iterator"
+array2iteratorRight,"iterator2array,array2iterator"
+ArrayBuffer,"Buffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,SharedArrayBuffer,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+arraybuffer2buffer,"Buffer,array2buffer,copyBuffer,string2buffer"
+arrayCtors,"typedarrayCtors"
+arrayDataType,"arrayDataTypes"
+arrayDataTypes,"typedarrayDataTypes,ndarrayDataTypes"
+arrayMinDataType,"arrayDataTypes,arrayPromotionRules,arraySafeCasts"
+arrayNextDataType,"arrayDataType,arrayDataTypes"
+arrayPromotionRules,"arrayDataTypes,arraySafeCasts,ndarrayPromotionRules"
+arraySafeCasts,"convertArray,convertArraySame,arrayDataTypes,arraySameKindCasts,ndarraySafeCasts"
+arraySameKindCasts,"convertArray,convertArraySame,arrayDataTypes,arraySafeCasts,ndarraySameKindCasts"
+arrayShape,"ndarray"
+arrayStream,"circularArrayStream,iteratorStream,stridedArrayStream"
+arrayview2iterator,"iterator2array,array2iterator,stridedarray2iterator,arrayview2iteratorRight"
+arrayview2iteratorRight,"iterator2array,array2iteratorRight,stridedarray2iterator,arrayview2iterator"
+AsyncIteratorSymbol,"Symbol,IteratorSymbol"
+bartlettTest,"vartest"
+base.abs,"base.abs2"
+base.abs2,"base.abs"
+base.absdiff,"base.reldiff,base.epsdiff"
+base.absInt32,"base.abs"
+base.acos,"base.acosh,base.asin,base.atan"
+base.acosh,"base.acos,base.asinh,base.atanh"
+base.acoth,"base.acosh,base.asinh,base.atanh"
+base.acovercos,"base.acoversin,base.avercos,base.covercos,base.vercos"
+base.acoversin,"base.acovercos,base.aversin,base.coversin,base.versin"
+base.ahavercos,"base.ahaversin,base.havercos,base.vercos"
+base.ahaversin,"base.ahavercos,base.haversin,base.versin"
+base.asin,"base.acos,base.asinh,base.atan"
+base.asinh,"base.acosh,base.asin,base.atanh"
+base.atan,"base.acos,base.asin,base.atanh"
+base.atan2,"base.atan"
+base.atanh,"base.acosh,base.asinh,base.atan"
+base.avercos,"base.aversin,base.versin"
+base.aversin,"base.avercos,base.vercos"
+base.bernoulli,""
+base.besselj0,"base.besselj1,base.bessely0,base.bessely1"
+base.besselj1,"base.besselj0,base.bessely0,base.bessely1"
+base.bessely0,"base.besselj0,base.besselj1,base.bessely1"
+base.bessely1,"base.besselj0,base.besselj1,base.bessely0"
+base.beta,"base.betainc,base.betaincinv,base.betaln"
+base.betainc,"base.beta,base.betaincinv,base.betaln"
+base.betaincinv,"base.beta,base.betainc,base.betaln"
+base.betaln,"base.beta,base.betainc,base.betaincinv"
+base.binet,"base.fibonacci,base.negafibonacci"
+base.binomcoef,""
+base.binomcoefln,""
+base.boxcox,"base.boxcoxinv,base.boxcox1p,base.boxcox1pinv"
+base.boxcox1p,"base.boxcox,base.boxcox1pinv,base.boxcoxinv"
+base.boxcox1pinv,"base.boxcox,base.boxcox1p,base.boxcoxinv"
+base.boxcoxinv,"base.boxcox,base.boxcox1p,base.boxcox1pinv"
+base.cabs,"base.cabs2,base.abs"
+base.cabs2,"base.cabs,base.abs2"
+base.cadd,"base.cdiv,base.cmul,base.csub"
+base.cbrt,"base.pow,base.sqrt"
+base.cceil,"base.cceiln,base.cfloor,base.cround"
+base.cceiln,"base.cceil,base.cfloorn,base.croundn"
+base.ccis,""
+base.cdiv,"base.cadd,base.cmul,base.csub"
+base.ceil,"base.ceiln,base.floor,base.round"
+base.ceil2,"base.ceil,base.ceil10,base.floor2,base.round2"
+base.ceil10,"base.ceil,base.ceil2,base.floor10,base.round10"
+base.ceilb,"base.ceil,base.ceiln,base.floorb,base.roundb"
+base.ceiln,"base.ceil,base.ceilb,base.floorn,base.roundn"
+base.ceilsd,"base.ceil,base.floorsd,base.roundsd,base.truncsd"
+base.cexp,""
+base.cflipsign,"base.cneg,base.csignum"
+base.cfloor,"base.cceil,base.cfloorn,base.cround"
+base.cfloorn,"base.cceiln,base.cfloor,base.croundn"
+base.cinv,"base.cdiv"
+base.clamp,"base.wrap"
+base.cmul,"base.cadd,base.cdiv,base.csub"
+base.cneg,"base.cabs"
+base.continuedFraction,""
+base.copysign,"base.flipsign"
+base.cos,"base.cospi,base.cosm1,base.sin,base.tan"
+base.cosh,"base.cos,base.sinh,base.tanh"
+base.cosm1,"base.cos"
+base.cospi,"base.cos"
+base.covercos,"base.coversin,base.vercos"
+base.coversin,"base.covercos,base.versin"
+base.cphase,"base.cabs"
+base.cpolar,"base.cabs,base.cphase"
+base.cround,"base.cceil,base.cfloor,base.croundn"
+base.croundn,"base.cceiln,base.cfloorn,base.cround"
+base.csignum,"base.signum"
+base.csub,"base.cadd,base.cdiv,base.cmul"
+base.dasum,"base.daxpy,base.dcopy"
+base.daxpy,"base.dasum,base.dcopy"
+base.dcopy,"base.dasum,base.daxpy"
+base.deg2rad,"base.rad2deg"
+base.digamma,"base.trigamma,base.gamma"
+base.diracDelta,"base.kroneckerDelta"
+base.dists.arcsine.Arcsine,""
+base.dists.arcsine.cdf,""
+base.dists.arcsine.entropy,""
+base.dists.arcsine.kurtosis,""
+base.dists.arcsine.logcdf,""
+base.dists.arcsine.logpdf,""
+base.dists.arcsine.mean,""
+base.dists.arcsine.median,""
+base.dists.arcsine.mode,""
+base.dists.arcsine.pdf,""
+base.dists.arcsine.quantile,""
+base.dists.arcsine.skewness,""
+base.dists.arcsine.stdev,""
+base.dists.arcsine.variance,""
+base.dists.bernoulli.Bernoulli,""
+base.dists.bernoulli.cdf,""
+base.dists.bernoulli.entropy,""
+base.dists.bernoulli.kurtosis,""
+base.dists.bernoulli.mean,""
+base.dists.bernoulli.median,""
+base.dists.bernoulli.mgf,""
+base.dists.bernoulli.mode,""
+base.dists.bernoulli.pmf,""
+base.dists.bernoulli.quantile,""
+base.dists.bernoulli.skewness,""
+base.dists.bernoulli.stdev,""
+base.dists.bernoulli.variance,""
+base.dists.beta.Beta,""
+base.dists.beta.cdf,""
+base.dists.beta.entropy,""
+base.dists.beta.kurtosis,""
+base.dists.beta.logcdf,""
+base.dists.beta.logpdf,""
+base.dists.beta.mean,""
+base.dists.beta.median,""
+base.dists.beta.mgf,""
+base.dists.beta.mode,""
+base.dists.beta.pdf,""
+base.dists.beta.quantile,""
+base.dists.beta.skewness,""
+base.dists.beta.stdev,""
+base.dists.beta.variance,""
+base.dists.betaprime.BetaPrime,""
+base.dists.betaprime.cdf,""
+base.dists.betaprime.kurtosis,""
+base.dists.betaprime.logcdf,""
+base.dists.betaprime.logpdf,""
+base.dists.betaprime.mean,""
+base.dists.betaprime.mode,""
+base.dists.betaprime.pdf,""
+base.dists.betaprime.quantile,""
+base.dists.betaprime.skewness,""
+base.dists.betaprime.stdev,""
+base.dists.betaprime.variance,""
+base.dists.binomial.Binomial,""
+base.dists.binomial.cdf,""
+base.dists.binomial.entropy,""
+base.dists.binomial.kurtosis,""
+base.dists.binomial.logpmf,""
+base.dists.binomial.mean,""
+base.dists.binomial.median,""
+base.dists.binomial.mgf,""
+base.dists.binomial.mode,""
+base.dists.binomial.pmf,""
+base.dists.binomial.quantile,""
+base.dists.binomial.skewness,""
+base.dists.binomial.stdev,""
+base.dists.binomial.variance,""
+base.dists.cauchy.Cauchy,""
+base.dists.cauchy.cdf,""
+base.dists.cauchy.entropy,""
+base.dists.cauchy.logcdf,""
+base.dists.cauchy.logpdf,""
+base.dists.cauchy.median,""
+base.dists.cauchy.mode,""
+base.dists.cauchy.pdf,""
+base.dists.cauchy.quantile,""
+base.dists.chi.cdf,""
+base.dists.chi.Chi,""
+base.dists.chi.entropy,""
+base.dists.chi.kurtosis,""
+base.dists.chi.logpdf,""
+base.dists.chi.mean,""
+base.dists.chi.mode,""
+base.dists.chi.pdf,""
+base.dists.chi.quantile,""
+base.dists.chi.skewness,""
+base.dists.chi.stdev,""
+base.dists.chi.variance,""
+base.dists.chisquare.cdf,""
+base.dists.chisquare.ChiSquare,""
+base.dists.chisquare.entropy,""
+base.dists.chisquare.kurtosis,""
+base.dists.chisquare.logpdf,""
+base.dists.chisquare.mean,""
+base.dists.chisquare.mgf,""
+base.dists.chisquare.mode,""
+base.dists.chisquare.pdf,""
+base.dists.chisquare.quantile,""
+base.dists.chisquare.skewness,""
+base.dists.chisquare.stdev,""
+base.dists.chisquare.variance,""
+base.dists.cosine.cdf,""
+base.dists.cosine.Cosine,""
+base.dists.cosine.kurtosis,""
+base.dists.cosine.logcdf,""
+base.dists.cosine.logpdf,""
+base.dists.cosine.mean,""
+base.dists.cosine.median,""
+base.dists.cosine.mgf,""
+base.dists.cosine.mode,""
+base.dists.cosine.pdf,""
+base.dists.cosine.quantile,""
+base.dists.cosine.skewness,""
+base.dists.cosine.stdev,""
+base.dists.cosine.variance,""
+base.dists.degenerate.cdf,""
+base.dists.degenerate.Degenerate,""
+base.dists.degenerate.entropy,""
+base.dists.degenerate.logcdf,""
+base.dists.degenerate.logpdf,""
+base.dists.degenerate.logpmf,""
+base.dists.degenerate.mean,""
+base.dists.degenerate.median,""
+base.dists.degenerate.mgf,""
+base.dists.degenerate.mode,""
+base.dists.degenerate.pdf,""
+base.dists.degenerate.pmf,""
+base.dists.degenerate.quantile,""
+base.dists.degenerate.stdev,""
+base.dists.degenerate.variance,""
+base.dists.discreteUniform.cdf,""
+base.dists.discreteUniform.DiscreteUniform,""
+base.dists.discreteUniform.kurtosis,""
+base.dists.discreteUniform.logcdf,""
+base.dists.discreteUniform.logpmf,""
+base.dists.discreteUniform.mean,""
+base.dists.discreteUniform.median,""
+base.dists.discreteUniform.mgf,""
+base.dists.discreteUniform.pmf,""
+base.dists.discreteUniform.quantile,""
+base.dists.discreteUniform.skewness,""
+base.dists.discreteUniform.stdev,""
+base.dists.discreteUniform.variance,""
+base.dists.erlang.cdf,""
+base.dists.erlang.entropy,""
+base.dists.erlang.Erlang,""
+base.dists.erlang.kurtosis,""
+base.dists.erlang.logpdf,""
+base.dists.erlang.mean,""
+base.dists.erlang.mgf,""
+base.dists.erlang.mode,""
+base.dists.erlang.pdf,""
+base.dists.erlang.quantile,""
+base.dists.erlang.skewness,""
+base.dists.erlang.stdev,""
+base.dists.erlang.variance,""
+base.dists.exponential.cdf,""
+base.dists.exponential.entropy,""
+base.dists.exponential.Exponential,""
+base.dists.exponential.kurtosis,""
+base.dists.exponential.logcdf,""
+base.dists.exponential.logpdf,""
+base.dists.exponential.mean,""
+base.dists.exponential.median,""
+base.dists.exponential.mgf,""
+base.dists.exponential.mode,""
+base.dists.exponential.pdf,""
+base.dists.exponential.quantile,""
+base.dists.exponential.skewness,""
+base.dists.exponential.stdev,""
+base.dists.exponential.variance,""
+base.dists.f.cdf,""
+base.dists.f.entropy,""
+base.dists.f.F,""
+base.dists.f.kurtosis,""
+base.dists.f.mean,""
+base.dists.f.mode,""
+base.dists.f.pdf,""
+base.dists.f.quantile,""
+base.dists.f.skewness,""
+base.dists.f.stdev,""
+base.dists.f.variance,""
+base.dists.frechet.cdf,""
+base.dists.frechet.entropy,""
+base.dists.frechet.Frechet,""
+base.dists.frechet.kurtosis,""
+base.dists.frechet.logcdf,""
+base.dists.frechet.logpdf,""
+base.dists.frechet.mean,""
+base.dists.frechet.median,""
+base.dists.frechet.mode,""
+base.dists.frechet.pdf,""
+base.dists.frechet.quantile,""
+base.dists.frechet.skewness,""
+base.dists.frechet.stdev,""
+base.dists.frechet.variance,""
+base.dists.gamma.cdf,""
+base.dists.gamma.entropy,""
+base.dists.gamma.Gamma,""
+base.dists.gamma.kurtosis,""
+base.dists.gamma.logpdf,""
+base.dists.gamma.mean,""
+base.dists.gamma.mgf,""
+base.dists.gamma.mode,""
+base.dists.gamma.pdf,""
+base.dists.gamma.quantile,""
+base.dists.gamma.skewness,""
+base.dists.gamma.stdev,""
+base.dists.gamma.variance,""
+base.dists.geometric.cdf,""
+base.dists.geometric.entropy,""
+base.dists.geometric.Geometric,""
+base.dists.geometric.kurtosis,""
+base.dists.geometric.logcdf,""
+base.dists.geometric.logpmf,""
+base.dists.geometric.mean,""
+base.dists.geometric.median,""
+base.dists.geometric.mgf,""
+base.dists.geometric.mode,""
+base.dists.geometric.pmf,""
+base.dists.geometric.quantile,""
+base.dists.geometric.skewness,""
+base.dists.geometric.stdev,""
+base.dists.geometric.variance,""
+base.dists.gumbel.cdf,""
+base.dists.gumbel.entropy,""
+base.dists.gumbel.Gumbel,""
+base.dists.gumbel.kurtosis,""
+base.dists.gumbel.logcdf,""
+base.dists.gumbel.logpdf,""
+base.dists.gumbel.mean,""
+base.dists.gumbel.median,""
+base.dists.gumbel.mgf,""
+base.dists.gumbel.mode,""
+base.dists.gumbel.pdf,""
+base.dists.gumbel.quantile,""
+base.dists.gumbel.skewness,""
+base.dists.gumbel.stdev,""
+base.dists.gumbel.variance,""
+base.dists.hypergeometric.cdf,""
+base.dists.hypergeometric.Hypergeometric,""
+base.dists.hypergeometric.kurtosis,""
+base.dists.hypergeometric.logpmf,""
+base.dists.hypergeometric.mean,""
+base.dists.hypergeometric.mode,""
+base.dists.hypergeometric.pmf,""
+base.dists.hypergeometric.quantile,""
+base.dists.hypergeometric.skewness,""
+base.dists.hypergeometric.stdev,""
+base.dists.hypergeometric.variance,""
+base.dists.invgamma.cdf,""
+base.dists.invgamma.entropy,""
+base.dists.invgamma.InvGamma,""
+base.dists.invgamma.kurtosis,""
+base.dists.invgamma.logpdf,""
+base.dists.invgamma.mean,""
+base.dists.invgamma.mode,""
+base.dists.invgamma.pdf,""
+base.dists.invgamma.quantile,""
+base.dists.invgamma.skewness,""
+base.dists.invgamma.stdev,""
+base.dists.invgamma.variance,""
+base.dists.kumaraswamy.cdf,""
+base.dists.kumaraswamy.Kumaraswamy,""
+base.dists.kumaraswamy.kurtosis,""
+base.dists.kumaraswamy.logcdf,""
+base.dists.kumaraswamy.logpdf,""
+base.dists.kumaraswamy.mean,""
+base.dists.kumaraswamy.median,""
+base.dists.kumaraswamy.mode,""
+base.dists.kumaraswamy.pdf,""
+base.dists.kumaraswamy.quantile,""
+base.dists.kumaraswamy.skewness,""
+base.dists.kumaraswamy.stdev,""
+base.dists.kumaraswamy.variance,""
+base.dists.laplace.cdf,""
+base.dists.laplace.entropy,""
+base.dists.laplace.kurtosis,""
+base.dists.laplace.Laplace,""
+base.dists.laplace.logcdf,""
+base.dists.laplace.logpdf,""
+base.dists.laplace.mean,""
+base.dists.laplace.median,""
+base.dists.laplace.mgf,""
+base.dists.laplace.mode,""
+base.dists.laplace.pdf,""
+base.dists.laplace.quantile,""
+base.dists.laplace.skewness,""
+base.dists.laplace.stdev,""
+base.dists.laplace.variance,""
+base.dists.levy.cdf,""
+base.dists.levy.entropy,""
+base.dists.levy.Levy,""
+base.dists.levy.logcdf,""
+base.dists.levy.logpdf,""
+base.dists.levy.mean,""
+base.dists.levy.median,""
+base.dists.levy.mode,""
+base.dists.levy.pdf,""
+base.dists.levy.quantile,""
+base.dists.levy.stdev,""
+base.dists.levy.variance,""
+base.dists.logistic.cdf,""
+base.dists.logistic.entropy,""
+base.dists.logistic.kurtosis,""
+base.dists.logistic.logcdf,""
+base.dists.logistic.Logistic,""
+base.dists.logistic.logpdf,""
+base.dists.logistic.mean,""
+base.dists.logistic.median,""
+base.dists.logistic.mgf,""
+base.dists.logistic.mode,""
+base.dists.logistic.pdf,""
+base.dists.logistic.quantile,""
+base.dists.logistic.skewness,""
+base.dists.logistic.stdev,""
+base.dists.logistic.variance,""
+base.dists.lognormal.cdf,""
+base.dists.lognormal.entropy,""
+base.dists.lognormal.kurtosis,""
+base.dists.lognormal.LogNormal,""
+base.dists.lognormal.logpdf,""
+base.dists.lognormal.mean,""
+base.dists.lognormal.median,""
+base.dists.lognormal.mode,""
+base.dists.lognormal.pdf,""
+base.dists.lognormal.quantile,""
+base.dists.lognormal.skewness,""
+base.dists.lognormal.stdev,""
+base.dists.lognormal.variance,""
+base.dists.negativeBinomial.cdf,""
+base.dists.negativeBinomial.kurtosis,""
+base.dists.negativeBinomial.logpmf,""
+base.dists.negativeBinomial.mean,""
+base.dists.negativeBinomial.mgf,""
+base.dists.negativeBinomial.mode,""
+base.dists.negativeBinomial.NegativeBinomial,""
+base.dists.negativeBinomial.pmf,""
+base.dists.negativeBinomial.quantile,""
+base.dists.negativeBinomial.skewness,""
+base.dists.negativeBinomial.stdev,""
+base.dists.negativeBinomial.variance,""
+base.dists.normal.cdf,""
+base.dists.normal.entropy,""
+base.dists.normal.kurtosis,""
+base.dists.normal.logpdf,""
+base.dists.normal.mean,""
+base.dists.normal.median,""
+base.dists.normal.mgf,""
+base.dists.normal.mode,""
+base.dists.normal.Normal,""
+base.dists.normal.pdf,""
+base.dists.normal.quantile,""
+base.dists.normal.skewness,""
+base.dists.normal.stdev,""
+base.dists.normal.variance,""
+base.dists.pareto1.cdf,""
+base.dists.pareto1.entropy,""
+base.dists.pareto1.kurtosis,""
+base.dists.pareto1.logcdf,""
+base.dists.pareto1.logpdf,""
+base.dists.pareto1.mean,""
+base.dists.pareto1.median,""
+base.dists.pareto1.mode,""
+base.dists.pareto1.Pareto1,""
+base.dists.pareto1.pdf,""
+base.dists.pareto1.quantile,""
+base.dists.pareto1.skewness,""
+base.dists.pareto1.variance,""
+base.dists.poisson.cdf,""
+base.dists.poisson.entropy,""
+base.dists.poisson.kurtosis,""
+base.dists.poisson.logpmf,""
+base.dists.poisson.mean,""
+base.dists.poisson.median,""
+base.dists.poisson.mgf,""
+base.dists.poisson.mode,""
+base.dists.poisson.pmf,""
+base.dists.poisson.Poisson,""
+base.dists.poisson.quantile,""
+base.dists.poisson.skewness,""
+base.dists.poisson.stdev,""
+base.dists.poisson.variance,""
+base.dists.rayleigh.cdf,""
+base.dists.rayleigh.entropy,""
+base.dists.rayleigh.kurtosis,""
+base.dists.rayleigh.logcdf,""
+base.dists.rayleigh.logpdf,""
+base.dists.rayleigh.mean,""
+base.dists.rayleigh.median,""
+base.dists.rayleigh.mgf,""
+base.dists.rayleigh.mode,""
+base.dists.rayleigh.pdf,""
+base.dists.rayleigh.quantile,""
+base.dists.rayleigh.Rayleigh,""
+base.dists.rayleigh.skewness,""
+base.dists.rayleigh.stdev,""
+base.dists.rayleigh.variance,""
+base.dists.t.cdf,""
+base.dists.t.entropy,""
+base.dists.t.kurtosis,""
+base.dists.t.mean,""
+base.dists.t.median,""
+base.dists.t.mode,""
+base.dists.t.pdf,""
+base.dists.t.quantile,""
+base.dists.t.skewness,""
+base.dists.t.stdev,""
+base.dists.t.T,""
+base.dists.t.variance,""
+base.dists.triangular.cdf,""
+base.dists.triangular.entropy,""
+base.dists.triangular.kurtosis,""
+base.dists.triangular.logcdf,""
+base.dists.triangular.logpdf,""
+base.dists.triangular.mean,""
+base.dists.triangular.median,""
+base.dists.triangular.mgf,""
+base.dists.triangular.mode,""
+base.dists.triangular.pdf,""
+base.dists.triangular.quantile,""
+base.dists.triangular.skewness,""
+base.dists.triangular.stdev,""
+base.dists.triangular.Triangular,""
+base.dists.triangular.variance,""
+base.dists.uniform.cdf,""
+base.dists.uniform.entropy,""
+base.dists.uniform.kurtosis,""
+base.dists.uniform.logcdf,""
+base.dists.uniform.logpdf,""
+base.dists.uniform.mean,""
+base.dists.uniform.median,""
+base.dists.uniform.mgf,""
+base.dists.uniform.pdf,""
+base.dists.uniform.quantile,""
+base.dists.uniform.skewness,""
+base.dists.uniform.stdev,""
+base.dists.uniform.Uniform,""
+base.dists.uniform.variance,""
+base.dists.weibull.cdf,""
+base.dists.weibull.entropy,""
+base.dists.weibull.kurtosis,""
+base.dists.weibull.logcdf,""
+base.dists.weibull.logpdf,""
+base.dists.weibull.mean,""
+base.dists.weibull.median,""
+base.dists.weibull.mgf,""
+base.dists.weibull.mode,""
+base.dists.weibull.pdf,""
+base.dists.weibull.quantile,""
+base.dists.weibull.skewness,""
+base.dists.weibull.stdev,""
+base.dists.weibull.variance,""
+base.dists.weibull.Weibull,""
+base.ellipe,"base.ellipk"
+base.ellipk,"base.ellipe"
+base.epsdiff,"base.absdiff,base.reldiff"
+base.erf,"base.erfc,base.erfinv,base.erfcinv"
+base.erfc,"base.erf,base.erfinv,base.erfcinv"
+base.erfcinv,"base.erf,base.erfc,base.erfinv"
+base.erfinv,"base.erf,base.erfc,base.erfcinv"
+base.eta,""
+base.evalpoly,"base.evalrational"
+base.evalrational,"base.evalpoly"
+base.exp,"base.exp10,base.exp2,base.expm1,base.ln"
+base.exp2,"base.exp,base.exp10"
+base.exp10,"base.exp,base.exp2"
+base.expit,"base.exp,base.logit"
+base.expm1,"base.exp,base.expm1rel"
+base.expm1rel,"base.exp,base.expm1"
+base.exponent,"base.exponentf"
+base.exponentf,"base.exponent"
+base.factorial,"base.factorialln"
+base.factorialln,"base.factorial"
+base.fallingFactorial,"base.risingFactorial"
+base.fibonacci,"base.binet,base.fibonacciIndex,base.lucas,base.negafibonacci"
+base.fibonacciIndex,"base.fibonacci"
+base.fibpoly,"base.evalpoly,base.lucaspoly"
+base.flipsign,"base.copysign"
+base.float32ToInt32,"base.float32ToUint32"
+base.float32ToUint32,"base.float32ToInt32"
+base.float64ToFloat32,""
+base.float64ToInt32,"base.float64ToUint32"
+base.float64ToUint32,"base.float64ToInt32"
+base.floor,"base.ceil,base.round"
+base.floor2,"base.ceil2,base.floor,base.floor10,base.round2"
+base.floor10,"base.ceil10,base.floor,base.floor2,base.round10"
+base.floorb,"base.ceilb,base.floor,base.floorn,base.roundb"
+base.floorn,"base.ceiln,base.floor,base.floorb,base.roundn"
+base.floorsd,"base.ceilsd,base.floor,base.roundsd,base.truncsd"
+base.fresnel,"base.fresnelc,base.fresnels"
+base.fresnelc,"base.fresnel,base.fresnels"
+base.fresnels,"base.fresnel,base.fresnelc"
+base.frexp,"base.ldexp"
+base.fromBinaryString,"base.fromBinaryStringf,base.toBinaryString"
+base.fromBinaryStringf,"base.toBinaryStringf,base.fromBinaryString"
+base.fromBinaryStringUint8,"base.fromBinaryStringUint16,base.fromBinaryStringUint32,base.toBinaryStringUint8"
+base.fromBinaryStringUint16,"base.toBinaryStringUint16,base.fromBinaryStringUint32,base.fromBinaryStringUint8"
+base.fromBinaryStringUint32,"base.fromBinaryStringUint16,base.toBinaryStringUint32,base.fromBinaryStringUint8"
+base.fromWordf,"base.fromWords"
+base.fromWords,"base.fromWordf"
+base.gamma,"base.gamma1pm1,base.gammainc,base.gammaincinv,base.gammaln"
+base.gamma1pm1,"base.gamma,base.gammainc,base.gammaincinv,base.gammaln"
+base.gammaDeltaRatio,"base.gamma"
+base.gammainc,"base.gamma,base.gamma1pm1,base.gammaincinv,base.gammaln"
+base.gammaincinv,"base.gamma,base.gamma1pm1,base.gammainc,base.gammaln"
+base.gammaLanczosSum,"base.gamma,base.gammaLanczosSumExpGScaled"
+base.gammaLanczosSumExpGScaled,"base.gamma,base.gammaLanczosSum"
+base.gammaln,"base.gamma,base.gammainc,base.gammaincinv"
+base.gasum,"base.dasum,base.sasum"
+base.gaxpy,"base.daxpy,base.saxpy"
+base.gcd,"base.lcm"
+base.gcopy,"base.dcopy"
+base.getHighWord,"base.getLowWord,base.setHighWord"
+base.getLowWord,"base.getHighWord,base.setHighWord"
+base.hacovercos,"base.hacoversin,base.havercos"
+base.hacoversin,"base.hacovercos,base.haversin"
+base.havercos,"base.haversin,base.vercos"
+base.haversin,"base.havercos,base.versin"
+base.heaviside,"base.ramp"
+base.hermitepoly,"base.evalpoly,base.normhermitepoly"
+base.hypot,""
+base.imul,"base.imuldw,base.uimul"
+base.imuldw,"base.imul,base.uimuldw"
+base.int32ToUint32,"base.uint32ToInt32"
+base.inv,"base.pow"
+base.isEven,"base.isOdd"
+base.isEvenInt32,"base.isEven,base.isOddInt32"
+base.isFinite,"base.isInfinite"
+base.isInfinite,"base.isFinite"
+base.isInteger,""
+base.isnan,""
+base.isNegativeInteger,"base.isInteger,base.isNonNegativeInteger,base.isNonPositiveInteger,base.isPositiveInteger"
+base.isNegativeZero,"base.isPositiveZero"
+base.isNonNegativeInteger,"base.isInteger,base.isNegativeInteger,base.isNonPositiveInteger,base.isPositiveInteger"
+base.isNonPositiveInteger,"base.isInteger,base.isNegativeInteger,base.isNonNegativeInteger,base.isPositiveInteger"
+base.isOdd,"base.isEven"
+base.isOddInt32,"base.isEvenInt32,base.isOdd"
+base.isPositiveInteger,"base.isInteger,base.isNegativeInteger,base.isNonNegativeInteger,base.isNonPositiveInteger"
+base.isPositiveZero,"base.isNegativeZero"
+base.isPow2Uint32,""
+base.isProbability,""
+base.isSafeInteger,""
+base.kernelBetainc,"base.betainc"
+base.kernelBetaincinv,"base.betaincinv"
+base.kernelCos,"base.cos,base.kernelSin,base.kernelTan"
+base.kernelSin,"base.kernelCos,base.kernelTan,base.sin"
+base.kernelTan,"base.kernelCos,base.kernelSin,base.tan"
+base.kroneckerDelta,"base.diracDelta"
+base.lcm,"base.gcd"
+base.ldexp,"base.frexp"
+base.ln,"base.exp,base.log10,base.log1p,base.log2"
+base.log,"base.exp,base.ln,base.log10,base.log1p,base.log2"
+base.log1mexp,"base.exp,base.ln,base.log1p,base.log1pexp"
+base.log1p,"base.ln,base.log"
+base.log1pexp,"base.exp,base.ln,base.log1mexp,base.log1p"
+base.log2,"base.exp2,base.ln,base.log"
+base.log10,"base.exp10,base.ln,base.log"
+base.logaddexp,"base.exp,base.ln"
+base.logit,""
+base.lucas,"base.fibonacci,base.negalucas"
+base.lucaspoly,"base.evalpoly,base.fibpoly"
+base.max,"base.maxabs,base.min"
+base.maxabs,"base.max,base.minabs"
+base.min,"base.max,base.minabs"
+base.minabs,"base.maxabs,base.min"
+base.minmax,"base.max,base.min,base.minmaxabs"
+base.minmaxabs,"base.maxabs,base.minabs,base.minmax"
+base.modf,""
+base.ndarray,"array,ndarray"
+base.ndarrayMemoized,"array,base.ndarray,ndarray,ndarrayMemoized"
+base.negafibonacci,"base.fibonacci,base.negalucas"
+base.negalucas,"base.fibonacci,base.lucas,base.negafibonacci"
+base.nonfibonacci,"base.fibonacci"
+base.normalize,"base.normalizef"
+base.normalizef,"base.normalize"
+base.normhermitepoly,"base.evalpoly,base.hermitepoly"
+base.pdiff,""
+base.polygamma,"base.trigamma,base.digamma,base.gamma"
+base.pow,"base.exp,base.powm1"
+base.powm1,"base.pow"
+base.rad2deg,"base.deg2rad"
+base.ramp,"base.heaviside"
+base.random.arcsine,"base.random.beta"
+base.random.bernoulli,"base.random.binomial"
+base.random.beta,""
+base.random.betaprime,""
+base.random.binomial,""
+base.random.boxMuller,""
+base.random.cauchy,""
+base.random.chi,""
+base.random.chisquare,""
+base.random.cosine,""
+base.random.discreteUniform,""
+base.random.erlang,""
+base.random.exponential,""
+base.random.f,""
+base.random.frechet,""
+base.random.gamma,""
+base.random.geometric,""
+base.random.gumbel,""
+base.random.hypergeometric,""
+base.random.improvedZiggurat,""
+base.random.invgamma,""
+base.random.kumaraswamy,""
+base.random.laplace,""
+base.random.levy,""
+base.random.logistic,""
+base.random.lognormal,""
+base.random.minstd,"base.random.minstdShuffle,base.random.mt19937,base.random.randi"
+base.random.minstdShuffle,"base.random.minstd,base.random.mt19937,base.random.randi"
+base.random.mt19937,"base.random.minstd,base.random.randi"
+base.random.negativeBinomial,""
+base.random.normal,""
+base.random.pareto1,""
+base.random.poisson,""
+base.random.randi,"base.random.minstd,base.random.minstdShuffle,base.random.mt19937"
+base.random.randn,"base.random.improvedZiggurat,base.random.randu"
+base.random.randu,"base.random.discreteUniform,base.random.randn"
+base.random.rayleigh,""
+base.random.t,""
+base.random.triangular,""
+base.random.uniform,"base.random.discreteUniform,base.random.randu"
+base.random.weibull,""
+base.reldiff,"base.absdiff,base.epsdiff"
+base.rempio2,""
+base.risingFactorial,"base.fallingFactorial"
+base.rotl32,"base.rotr32"
+base.rotr32,"base.rotl32"
+base.round,"base.ceil,base.floor,base.roundn,base.trunc"
+base.round2,"base.ceil2,base.floor2,base.round,base.round10"
+base.round10,"base.ceil10,base.floor10,base.round,base.round2"
+base.roundb,"base.ceilb,base.floorb,base.round,base.roundn"
+base.roundn,"base.ceiln,base.floorn,base.round,base.roundb"
+base.roundsd,"base.ceilsd,base.floorsd,base.round,base.truncsd"
+base.rsqrt,"base.sqrt"
+base.sasum,"base.dasum"
+base.saxpy,"base.daxpy"
+base.scopy,"base.dcopy"
+base.setHighWord,"base.getHighWord,base.setLowWord"
+base.setLowWord,"base.getLowWord,base.setHighWord"
+base.sici,""
+base.signbit,"base.signbitf"
+base.signbitf,"base.signbit"
+base.significandf,""
+base.signum,""
+base.sin,"base.cos,base.sinpi,base.tan"
+base.sinc,"base.sin"
+base.sincos,"base.cos,base.sin,base.sincospi"
+base.sincospi,"base.cospi,base.sincos,base.sinpi"
+base.sinh,"base.cosh,base.sin,base.tanh"
+base.sinpi,"base.sin"
+base.spence,""
+base.sqrt,"base.cbrt,base.rsqrt"
+base.sqrt1pm1,"base.sqrt"
+base.sumSeries,""
+base.tan,"base.cos,base.sin"
+base.tanh,"base.cosh,base.sinh,base.tan"
+base.toBinaryString,"base.fromBinaryString,base.toBinaryStringf"
+base.toBinaryStringf,"base.fromBinaryStringf,base.toBinaryString"
+base.toBinaryStringUint8,"base.toBinaryString"
+base.toBinaryStringUint16,"base.toBinaryString"
+base.toBinaryStringUint32,"base.toBinaryString"
+base.toWordf,"base.fromWordf,base.toWords"
+base.toWords,"base.fromWords,base.toWordf"
+base.trigamma,"base.digamma,base.gamma"
+base.trunc,"base.ceil,base.floor,base.round"
+base.trunc2,"base.ceil2,base.floor2,base.round2,base.trunc,base.trunc10"
+base.trunc10,"base.ceil10,base.floor10,base.round10,base.trunc,base.trunc2"
+base.truncb,"base.ceilb,base.floorb,base.roundb,base.trunc,base.truncn"
+base.truncn,"base.ceiln,base.floorn,base.roundn,base.trunc,base.truncb"
+base.truncsd,"base.ceilsd,base.floorsd,base.roundsd,base.trunc"
+base.uimul,"base.imul"
+base.uimuldw,"base.imuldw,base.uimul"
+base.uint32ToInt32,""
+base.vercos,"base.cos,base.versin"
+base.versin,"base.cos,base.sin,base.vercos"
+base.wrap,"base.clamp"
+base.xlog1py,"base.log1p,base.xlogy"
+base.xlogy,"base.ln,base.xlog1py"
+base.zeta,""
+BERNDT_CPS_WAGES_1985,""
+bifurcate,"bifurcateBy,bifurcateOwn,group"
+bifurcateBy,"bifurcate,groupBy"
+bifurcateByAsync,"bifurcateBy,groupByAsync"
+bifurcateIn,"bifurcate,bifurcateBy,bifurcateOwn,groupIn"
+bifurcateOwn,"bifurcate,bifurcateBy,bifurcateIn,groupOwn"
+binomialTest,""
+Buffer,"ArrayBuffer"
+buffer2json,"typedarray2json,reviveBuffer"
+capitalize,"uncapitalize,uppercase"
+capitalizeKeys,"uncapitalizeKeys,uppercaseKeys"
+CATALAN,""
+CBRT_EPS,"EPS,SQRT_EPS"
+chdir,"cwd"
+chi2gof,""
+circarray2iterator,"array2iterator,stridedarray2iterator"
+circularArrayStream,"arrayStream,iteratorStream,stridedArrayStream"
+CircularBuffer,"FIFO,Stack"
+CMUDICT,""
+complex,"Complex128,Complex64"
+Complex64,"complex,Complex128"
+COMPLEX64_NUM_BYTES,"COMPLEX128_NUM_BYTES,FLOAT32_NUM_BYTES"
+Complex64Array,"Complex128Array,complex,Complex64"
+Complex128,"complex,Complex64"
+COMPLEX128_NUM_BYTES,"COMPLEX64_NUM_BYTES,FLOAT64_NUM_BYTES"
+Complex128Array,"Complex64Array,complex,Complex128"
+compose,"composeAsync"
+composeAsync,"compose"
+configdir,"homedir,tmpdir"
+conj,"imag,real,reim"
+constantFunction,"argumentFunction,identity"
+constantStream,"arrayStream,iteratorStream"
+constructorName,"functionName"
+contains,""
+convertArray,"convertArraySame"
+convertArraySame,"convertArray"
+convertPath,""
+copy,"merge"
+copyBuffer,"allocUnsafe,Buffer"
+countBy,"group,groupBy"
+countByAsync,"countBy,groupByAsync,tabulateByAsync"
+curry,"curryRight,uncurry,uncurryRight"
+curryRight,"curry,uncurry,uncurryRight"
+cwd,"chdir"
+DALE_CHALL_NEW,""
+datasets,""
+dayOfQuarter,"dayOfYear"
+dayOfYear,"dayOfQuarter"
+daysInMonth,"daysInYear"
+daysInYear,"daysInMonth"
+debugSinkStream,"debugStream,inspectSinkStream"
+debugStream,"debugSinkStream,inspectStream"
+deepEqual,"isStrictEqual,isSameValue"
+deepGet,"deepPluck,deepSet"
+deepHasOwnProp,"deepHasProp,hasOwnProp,deepGet,deepPluck,deepSet"
+deepHasProp,"deepHasOwnProp,hasOwnProp,deepGet,deepPluck,deepSet"
+deepPluck,"deepGet,deepSet"
+deepSet,"deepGet,deepPluck"
+defineMemoizedProperty,"setMemoizedReadOnly,defineProperty"
+defineProperties,"defineProperty,setReadOnly"
+defineProperty,"defineProperties,setReadOnly"
+dirname,"extname"
+DoublyLinkedList,"LinkedList,Stack"
+doUntil,"doUntilAsync,doUntilEach,doWhile,until,whilst"
+doUntilAsync,"doUntil,doWhileAsync,untilAsync,whileAsync"
+doUntilEach,"doUntilEachRight,doWhileEach,untilEach"
+doUntilEachRight,"doUntilEach,doWhileEachRight,untilEachRight"
+doWhile,"doUntil,doWhileAsync,doWhileEach,until,whilst"
+doWhileAsync,"doUntilAsync,doWhile,untilAsync,whileAsync"
+doWhileEach,"doUntilEach,doWhileEachRight,whileEach"
+doWhileEachRight,"doUntilEachRight,doWhileEach,whileEachRight"
+E,""
+emptyStream,"constantStream"
+endsWith,"startsWith"
+enumerableProperties,"enumerablePropertiesIn,enumerablePropertySymbols,inheritedEnumerableProperties,objectKeys,nonEnumerableProperties,properties"
+enumerablePropertiesIn,"enumerableProperties,enumerablePropertySymbolsIn,inheritedEnumerableProperties,keysIn,nonEnumerablePropertiesIn,propertiesIn"
+enumerablePropertySymbols,"enumerablePropertySymbolsIn,inheritedEnumerablePropertySymbols,objectKeys,nonEnumerablePropertySymbols,propertySymbols"
+enumerablePropertySymbolsIn,"enumerablePropertySymbols,inheritedEnumerablePropertySymbols,keysIn,nonEnumerablePropertySymbolsIn,propertySymbolsIn"
+ENV,"ARGV"
+EPS,"FLOAT32_EPS"
+error2json,"reviveError"
+EULERGAMMA,""
+every,"any,everyBy,forEach,none,some"
+everyBy,"anyBy,everyByRight,forEach,noneBy,someBy"
+everyByAsync,"anyByAsync,everyBy,everyByRightAsync,forEachAsync,noneByAsync,someByAsync"
+everyByRight,"anyBy,every,everyBy,forEachRight,noneByRight,someByRight"
+everyByRightAsync,"anyByRightAsync,everyByAsync,everyByRight,forEachRightAsync,noneByRightAsync,someByRightAsync"
+evil,""
+exists,"readFile,readDir"
+expandContractions,""
+extname,"dirname"
+fastmath.abs,"base.abs"
+fastmath.acosh,"base.acosh"
+fastmath.ampbm,"base.hypot"
+fastmath.asinh,"base.asinh"
+fastmath.atanh,"base.atanh"
+fastmath.hypot,"base.hypot"
+fastmath.log2Uint32,"base.log2"
+fastmath.max,"base.max"
+fastmath.min,"base.min"
+fastmath.powint,"base.pow"
+fastmath.sqrtUint32,"base.sqrt"
+FEMALE_FIRST_NAMES_EN,"MALE_FIRST_NAMES_EN"
+FIFO,"Stack"
+find,""
+flattenArray,"flattenObject"
+flattenObject,"flattenArray"
+flignerTest,"bartlettTest"
+FLOAT16_CBRT_EPS,"FLOAT16_EPS,FLOAT16_SQRT_EPS,FLOAT32_CBRT_EPS,CBRT_EPS"
+FLOAT16_EPS,"FLOAT32_EPS,EPS"
+FLOAT16_EXPONENT_BIAS,"FLOAT32_EXPONENT_BIAS,FLOAT64_EXPONENT_BIAS"
+FLOAT16_MAX,"FLOAT32_MAX,FLOAT64_MAX"
+FLOAT16_MAX_SAFE_INTEGER,"FLOAT16_MIN_SAFE_INTEGER,FLOAT32_MAX_SAFE_INTEGER,FLOAT64_MAX_SAFE_INTEGER"
+FLOAT16_MIN_SAFE_INTEGER,"FLOAT16_MAX_SAFE_INTEGER,FLOAT32_MIN_SAFE_INTEGER,FLOAT64_MIN_SAFE_INTEGER"
+FLOAT16_NINF,"FLOAT16_PINF,FLOAT32_NINF,NINF"
+FLOAT16_NUM_BYTES,"FLOAT32_NUM_BYTES,FLOAT64_NUM_BYTES"
+FLOAT16_PINF,"FLOAT16_NINF,FLOAT32_PINF,PINF"
+FLOAT16_PRECISION,"FLOAT32_PRECISION,FLOAT64_PRECISION"
+FLOAT16_SMALLEST_NORMAL,"FLOAT16_SMALLEST_SUBNORMAL,FLOAT32_SMALLEST_NORMAL,FLOAT64_SMALLEST_NORMAL"
+FLOAT16_SMALLEST_SUBNORMAL,"FLOAT16_SMALLEST_NORMAL,FLOAT32_SMALLEST_SUBNORMAL,FLOAT64_SMALLEST_SUBNORMAL"
+FLOAT16_SQRT_EPS,"FLOAT16_EPS,FLOAT32_SQRT_EPS,SQRT_EPS"
+FLOAT32_CBRT_EPS,"FLOAT32_EPS,FLOAT32_SQRT_EPS,CBRT_EPS"
+FLOAT32_EPS,"EPS"
+FLOAT32_EXPONENT_BIAS,"FLOAT16_EXPONENT_BIAS,FLOAT64_EXPONENT_BIAS"
+FLOAT32_MAX,"FLOAT16_MAX,FLOAT64_MAX"
+FLOAT32_MAX_SAFE_INTEGER,"FLOAT16_MAX_SAFE_INTEGER,FLOAT32_MIN_SAFE_INTEGER,FLOAT64_MAX_SAFE_INTEGER"
+FLOAT32_MIN_SAFE_INTEGER,"FLOAT16_MIN_SAFE_INTEGER,FLOAT32_MAX_SAFE_INTEGER,FLOAT64_MIN_SAFE_INTEGER"
+FLOAT32_NINF,"FLOAT32_PINF,NINF"
+FLOAT32_NUM_BYTES,"FLOAT16_NUM_BYTES,FLOAT64_NUM_BYTES"
+FLOAT32_PINF,"FLOAT32_NINF,PINF"
+FLOAT32_PRECISION,"FLOAT16_PRECISION,FLOAT64_PRECISION"
+FLOAT32_SMALLEST_NORMAL,"FLOAT32_SMALLEST_SUBNORMAL,FLOAT64_SMALLEST_NORMAL"
+FLOAT32_SMALLEST_SUBNORMAL,"FLOAT32_SMALLEST_NORMAL,FLOAT64_SMALLEST_SUBNORMAL"
+FLOAT32_SQRT_EPS,"FLOAT32_EPS,SQRT_EPS"
+Float32Array,"ArrayBuffer,Float64Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+FLOAT64_EXPONENT_BIAS,"FLOAT16_EXPONENT_BIAS,FLOAT32_EXPONENT_BIAS"
+FLOAT64_HIGH_WORD_EXPONENT_MASK,"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK"
+FLOAT64_HIGH_WORD_SIGNIFICAND_MASK,"FLOAT64_HIGH_WORD_EXPONENT_MASK"
+FLOAT64_MAX,"FLOAT16_MAX,FLOAT32_MAX"
+FLOAT64_MAX_BASE2_EXPONENT,"FLOAT64_MAX_BASE10_EXPONENT,FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE2_EXPONENT"
+FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,FLOAT64_MAX_BASE2_EXPONENT,FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"
+FLOAT64_MAX_BASE10_EXPONENT,"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,FLOAT64_MAX_BASE2_EXPONENT,FLOAT64_MIN_BASE10_EXPONENT"
+FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE10_EXPONENT,FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL"
+FLOAT64_MAX_LN,"FLOAT64_MIN_LN"
+FLOAT64_MAX_SAFE_FIBONACCI,"FLOAT64_MAX_SAFE_NTH_FIBONACCI"
+FLOAT64_MAX_SAFE_INTEGER,"FLOAT16_MAX_SAFE_INTEGER,FLOAT32_MAX_SAFE_INTEGER,FLOAT64_MIN_SAFE_INTEGER"
+FLOAT64_MAX_SAFE_LUCAS,"FLOAT64_MAX_SAFE_FIBONACCI,FLOAT64_MAX_SAFE_NTH_LUCAS"
+FLOAT64_MAX_SAFE_NTH_FIBONACCI,"FLOAT64_MAX_SAFE_FIBONACCI"
+FLOAT64_MAX_SAFE_NTH_LUCAS,"FLOAT64_MAX_SAFE_LUCAS,FLOAT64_MAX_SAFE_NTH_FIBONACCI"
+FLOAT64_MIN_BASE2_EXPONENT,"FLOAT64_MAX_BASE2_EXPONENT,FLOAT64_MIN_BASE10_EXPONENT,FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"
+FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE2_EXPONENT"
+FLOAT64_MIN_BASE10_EXPONENT,"FLOAT64_MAX_BASE10_EXPONENT,FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE2_EXPONENT"
+FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,FLOAT64_MIN_BASE10_EXPONENT,FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"
+FLOAT64_MIN_LN,"FLOAT64_MAX_LN"
+FLOAT64_MIN_SAFE_INTEGER,"FLOAT16_MIN_SAFE_INTEGER,FLOAT32_MIN_SAFE_INTEGER,FLOAT64_MAX_SAFE_INTEGER"
+FLOAT64_NUM_BYTES,"FLOAT16_NUM_BYTES,FLOAT32_NUM_BYTES"
+FLOAT64_PRECISION,"FLOAT16_PRECISION,FLOAT32_PRECISION"
+FLOAT64_SMALLEST_NORMAL,"FLOAT32_SMALLEST_NORMAL,FLOAT64_SMALLEST_SUBNORMAL"
+FLOAT64_SMALLEST_SUBNORMAL,"FLOAT32_SMALLEST_SUBNORMAL,FLOAT64_SMALLEST_NORMAL"
+Float64Array,"ArrayBuffer,Float32Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+forEach,"forEachAsync,forEachRight"
+forEachAsync,"forEach,forEachRightAsync"
+forEachRight,"forEach,forEachRightAsync"
+forEachRightAsync,"forEachAsync,forEachRight"
+forIn,"forEach,forOwn"
+forOwn,"forEach,forIn"
+FOURTH_PI,"PI"
+FOURTH_ROOT_EPS,"EPS"
+FRB_SF_WAGE_RIGIDITY,""
+fromCodePoint,""
+functionName,"constructorName"
+functionSequence,"compose,functionSequenceAsync"
+functionSequenceAsync,"composeAsync,functionSequence"
+GAMMA_LANCZOS_G,""
+getegid,"geteuid,getgid,getuid"
+geteuid,"getegid,getgid,getuid"
+getgid,"getegid,geteuid,getuid"
+getGlobal,""
+getPrototypeOf,"isPrototypeOf"
+getuid,"getegid,geteuid,getgid"
+GLAISHER,""
+group,"bifurcate,countBy,groupBy"
+groupBy,"bifurcateBy,countBy,group"
+groupByAsync,"bifurcateByAsync,countByAsync,groupBy"
+groupIn,"bifurcateIn,groupBy,groupOwn"
+groupOwn,"bifurcateOwn,group,groupBy"
+HALF_LN2,"LN2"
+HALF_PI,"PI"
+HARRISON_BOSTON_HOUSE_PRICES,"HARRISON_BOSTON_HOUSE_PRICES_CORRECTED,PACE_BOSTON_HOUSE_PRICES"
+HARRISON_BOSTON_HOUSE_PRICES_CORRECTED,"HARRISON_BOSTON_HOUSE_PRICES,PACE_BOSTON_HOUSE_PRICES"
+hasArrayBufferSupport,"hasFloat32ArraySupport,hasFloat64ArraySupport,hasInt16ArraySupport,hasInt32ArraySupport,hasInt8ArraySupport,hasNodeBufferSupport,hasSharedArrayBufferSupport,hasUint16ArraySupport,hasUint32ArraySupport,hasUint8ArraySupport,hasUint8ClampedArraySupport"
+hasAsyncAwaitSupport,""
+hasAsyncIteratorSymbolSupport,"hasIteratorSymbolSupport,hasSymbolSupport"
+hasClassSupport,""
+hasDefinePropertiesSupport,"hasDefinePropertySupport"
+hasDefinePropertySupport,"hasDefinePropertiesSupport"
+hasFloat32ArraySupport,""
+hasFloat64ArraySupport,""
+hasFunctionNameSupport,""
+hasGeneratorSupport,""
+hasInt8ArraySupport,""
+hasInt16ArraySupport,""
+hasInt32ArraySupport,""
+hasIteratorSymbolSupport,"hasAsyncIteratorSymbolSupport,hasSymbolSupport"
+hasMapSupport,""
+hasNodeBufferSupport,""
+hasOwnProp,"hasProp"
+hasProp,"hasOwnProp"
+hasProxySupport,""
+hasSetSupport,""
+hasSharedArrayBufferSupport,"hasArrayBufferSupport,hasFloat32ArraySupport,hasFloat64ArraySupport,hasInt16ArraySupport,hasInt32ArraySupport,hasInt8ArraySupport,hasNodeBufferSupport,hasUint16ArraySupport,hasUint32ArraySupport,hasUint8ArraySupport,hasUint8ClampedArraySupport"
+hasSymbolSupport,"hasIteratorSymbolSupport"
+hasToStringTagSupport,""
+hasUint8ArraySupport,""
+hasUint8ClampedArraySupport,""
+hasUint16ArraySupport,""
+hasUint32ArraySupport,""
+hasWeakMapSupport,""
+hasWeakSetSupport,""
+hasWebAssemblySupport,""
+HERNDON_VENUS_SEMIDIAMETERS,""
+homedir,"configdir,tmpdir"
+HOURS_IN_DAY,"HOURS_IN_WEEK"
+HOURS_IN_WEEK,"HOURS_IN_DAY"
+hoursInMonth,"hoursInYear"
+hoursInYear,"hoursInMonth"
+httpServer,""
+identity,"constantFunction"
+ifelse,"ifelseAsync,ifthen"
+ifelseAsync,"ifthenAsync,ifelse"
+ifthen,"ifthenAsync,ifelse"
+ifthenAsync,"ifelseAsync,ifthen"
+imag,"real,reim"
+IMG_ACANTHUS_MOLLIS,"IMG_ALLIUM_OREOPHILUM"
+IMG_AIRPLANE_FROM_ABOVE,""
+IMG_ALLIUM_OREOPHILUM,"IMG_ACANTHUS_MOLLIS"
+IMG_BLACK_CANYON,""
+IMG_DUST_BOWL_HOME,""
+IMG_FRENCH_ALPINE_LANDSCAPE,""
+IMG_LOCOMOTION_HOUSE_CAT,"IMG_LOCOMOTION_NUDE_MALE"
+IMG_LOCOMOTION_NUDE_MALE,"IMG_LOCOMOTION_HOUSE_CAT"
+IMG_MARCH_PASTORAL,""
+IMG_NAGASAKI_BOATS,""
+incrapcorr,"incrmapcorr,incrpcorr,incrpcorr2"
+incrcount,"incrmean,incrsum,incrsummary"
+incrcovariance,"incrmcovariance,incrpcorr,incrvariance"
+incrcovmat,"incrcovariance,incrpcorrmat"
+incrcv,"incrmean,incrmcv,incrstdev,incrvmr"
+increwmean,"increwvariance,incrmean,incrmmean,incrwmean"
+increwstdev,"increwvariance,incrmstdev,incrstdev"
+increwvariance,"increwmean,increwstdev,incrvariance,incrmvariance"
+incrgmean,"incrhmean,incrmean,incrmgmean,incrsummary"
+incrgrubbs,"incrmgrubbs"
+incrhmean,"incrgmean,incrmean,incrmhmean,incrsummary"
+incrkmeans,""
+incrkurtosis,"incrmean,incrskewness,incrstdev,incrsummary,incrvariance"
+incrmaape,"incrmae,incrmape,incrmean,incrmmaape"
+incrmae,"incrmape,incrme,incrmean,incrmmae"
+incrmapcorr,"incrapcorr,incrmpcorr,incrmpcorr2"
+incrmape,"incrmaape,incrmae,incrmean,incrmmape"
+incrmax,"incrmidrange,incrmin,incrmmax,incrrange,incrsummary"
+incrmaxabs,"incrmax,incrminabs,incrmmaxabs"
+incrmcovariance,"incrcovariance,incrmpcorr,incrmvariance"
+incrmcv,"incrcv,incrmmean,incrmstdev,incrmvmr"
+incrmda,"incrmape,incrmmda"
+incrme,"incrmae,incrmean,incrmme"
+incrmean,"incrmidrange,incrmmean,incrstdev,incrsum,incrsummary,incrvariance"
+incrmeanabs,"incrmean,incrmmeanabs,incrsumabs"
+incrmeanabs2,"incrmean,incrmeanabs,incrmmeanabs2,incrsumabs2"
+incrmeanstdev,"incrmean,incrmeanvar,incrmmeanstdev,incrstdev"
+incrmeanvar,"incrmean,incrmeanstdev,incrmmeanvar,incrvariance"
+incrmgmean,"incrgmean,incrmhmean,incrmmean"
+incrmgrubbs,"incrgrubbs"
+incrmhmean,"incrhmean,incrmgmean,incrmmean"
+incrmidrange,"incrmean,incrmax,incrmin,incrrange,incrsummary"
+incrmin,"incrmax,incrmidrange,incrmmin,incrrange,incrsummary"
+incrminabs,"incrmaxabs,incrmin,incrmminabs"
+incrminmax,"incrmax,incrmin,incrmminmax,incrrange"
+incrminmaxabs,"incrmaxabs,incrminabs,incrminmax,incrmminmaxabs"
+incrmmaape,"incrmaape,incrmmape,incrmmpe,incrmmean"
+incrmmae,"incrmae,incrmme,incrmmean"
+incrmmape,"incrmape,incrmmaape,incrmmpe,incrmmean"
+incrmmax,"incrmax,incrmmidrange,incrmmin,incrmrange,incrmsummary"
+incrmmaxabs,"incrmaxabs,incrmmax,incrmminabs"
+incrmmda,"incrmda,incrmmape"
+incrmme,"incrme,incrmmae,incrmmean"
+incrmmean,"incrmean,incrmsum,incrmstdev,incrmsummary,incrmvariance"
+incrmmeanabs,"incrmeanabs,incrmmean,incrmsumabs"
+incrmmeanabs2,"incrmeanabs2,incrmmeanabs,incrmsumabs2"
+incrmmeanstdev,"incrmeanstdev,incrmmean,incrmmeanvar,incrmstdev"
+incrmmeanvar,"incrmeanvar,incrmmean,incrmmeanstdev,incrmvariance"
+incrmmidrange,"incrmmean,incrmmax,incrmmin,incrmrange"
+incrmmin,"incrmin,incrmmax,incrmmidrange,incrmrange,incrmsummary"
+incrmminabs,"incrminabs,incrmmaxabs,incrmmin"
+incrmminmax,"incrmax,incrmin,incrmmax,incrminmax,incrmmin,incrmrange"
+incrmminmaxabs,"incrminmaxabs,incrmmax,incrmmaxabs,incrmmin,incrmminabs,incrmminmax"
+incrmmpe,"incrmmape,incrmme,incrmpe"
+incrmmse,"incrmrmse,incrmrss,incrmse"
+incrmpcorr,"incrmcovariance,incrmpcorrdist,incrpcorr"
+incrmpcorr2,"incrmapcorr,incrmpcorr,incrpcorr2"
+incrmpcorrdist,"incrmpcorr,incrpcorrdist"
+incrmpe,"incrmape,incrme,incrmmpe"
+incrmprod,"incrmsum,incrprod"
+incrmrange,"incrmmax,incrmmean,incrmmin,incrmsummary,incrrange"
+incrmrmse,"incrmmse,incrmrss,incrrmse"
+incrmrss,"incrrss,incrmmse,incrmrmse"
+incrmse,"incrmmse,incrrmse,incrrss"
+incrmstdev,"incrmmean,incrmsummary,incrmvariance,incrstdev"
+incrmsum,"incrmmean,incrmsummary,incrsum"
+incrmsumabs,"incrmmeanabs,incrmsum,incrsum,incrsumabs"
+incrmsumabs2,"incrmmeanabs2,incrmsumabs,incrsumabs,incrsumabs2"
+incrmsummary,"incrmmean,incrmstdev,incrmsum,incrmvariance,incrsummary"
+incrmsumprod,"incrmprod,incrmsum,incrsumprod"
+incrmvariance,"incrmmean,incrmstdev,incrmsummary,incrvariance"
+incrmvmr,"incrmmean,incrmvariance,incrvmr"
+incrpcorr,"incrcovariance,incrmpcorr,incrsummary"
+incrpcorr2,"incrapcorr,incrmpcorr2,incrpcorr"
+incrpcorrdist,"incrcovariance,incrpcorr,incrsummary"
+incrpcorrdistmat,"incrpcorrdist,incrpcorrmat"
+incrpcorrmat,"incrcovmat,incrpcorr,incrpcorrdistmat"
+incrprod,"incrmprod,incrsum,incrsummary"
+incrrange,"incrmax,incrmean,incrmin,incrmrange,incrsummary"
+incrrmse,"incrmrmse,incrmse,incrrss"
+incrrss,"incrmrss,incrmse,incrrmse"
+incrskewness,"incrkurtosis,incrmean,incrstdev,incrsummary,incrvariance"
+incrspace,"linspace,logspace"
+incrstdev,"incrkurtosis,incrmean,incrmstdev,incrskewness,incrsummary,incrvariance"
+incrsum,"incrcount,incrmean,incrmsum,incrprod,incrsummary"
+incrsumabs,"incrmeanabs,incrmsumabs,incrsum"
+incrsumabs2,"incrmeanabs2,incrmsumabs2,incrsumabs"
+incrsummary,"incrcount,incrkurtosis,incrmax,incrmean,incrmidrange,incrmin,incrmsummary,incrrange,incrskewness,incrstdev,incrsum,incrvariance"
+incrsumprod,"incrmsumprod,incrprod,incrsum"
+incrvariance,"incrkurtosis,incrmean,incrmstdev,incrskewness,incrstdev,incrsummary"
+incrvmr,"incrmean,incrmvmr,incrvariance"
+incrwmean,"increwmean,incrmean,incrmmean"
+ind2sub,"array,ndarray,sub2ind"
+indexOf,""
+inherit,""
+inheritedEnumerableProperties,"enumerableProperties,enumerablePropertiesIn,inheritedEnumerablePropertySymbols,inheritedKeys,inheritedNonEnumerableProperties,inheritedProperties"
+inheritedEnumerablePropertySymbols,"enumerableProperties,enumerablePropertySymbols,inheritedKeys,nonEnumerablePropertySymbols,nonEnumerablePropertySymbolsIn,propertySymbols"
+inheritedKeys,"objectKeys,keysIn,inheritedPropertyNames,inheritedPropertySymbols"
+inheritedNonEnumerableProperties,"inheritedEnumerableProperties,inheritedNonEnumerablePropertyNames,inheritedNonEnumerablePropertySymbols,inheritedKeys,nonEnumerableProperties,nonEnumerablePropertiesIn,properties"
+inheritedNonEnumerablePropertyNames,"inheritedNonEnumerableProperties,inheritedNonEnumerablePropertySymbols,objectKeys,nonEnumerablePropertyNames,nonEnumerablePropertyNamesIn,nonEnumerablePropertySymbols,propertyNames"
+inheritedNonEnumerablePropertySymbols,"inheritedNonEnumerableProperties,inheritedNonEnumerablePropertyNames,nonEnumerableProperties,nonEnumerablePropertyNames,nonEnumerablePropertySymbols,nonEnumerablePropertySymbolsIn,propertySymbols"
+inheritedProperties,"properties,propertiesIn,inheritedPropertyNames,inheritedPropertySymbols"
+inheritedPropertyDescriptor,"propertyDescriptor,propertyDescriptorIn,inheritedKeys,inheritedPropertyDescriptors,inheritedPropertyNames,inheritedPropertySymbols"
+inheritedPropertyDescriptors,"propertyDescriptors,propertyDescriptorsIn,inheritedKeys,inheritedPropertyNames,inheritedPropertySymbols"
+inheritedPropertyNames,"inheritedKeys,inheritedPropertyDescriptors,inheritedPropertySymbols,propertyNames,propertyNamesIn"
+inheritedPropertySymbols,"inheritedKeys,inheritedPropertyDescriptors,inheritedPropertyNames,propertySymbols,propertySymbolsIn"
+inheritedWritableProperties,"inheritedWritablePropertyNames,inheritedWritablePropertySymbols,writableProperties,writablePropertiesIn,properties"
+inheritedWritablePropertyNames,"inheritedWritablePropertySymbols,writablePropertyNames,writablePropertyNamesIn,properties"
+inheritedWritablePropertySymbols,"inheritedWritablePropertyNames,writablePropertySymbols,writablePropertySymbolsIn,properties"
+inmap,"forEach,inmapRight"
+inmapAsync,"forEachAsync,inmapRightAsync,inmap"
+inmapRight,"forEachRight,inmap"
+inmapRightAsync,"forEachRightAsync,inmapAsync,inmapRight"
+inspectSinkStream,"debugSinkStream,inspectStream"
+inspectStream,"debugStream"
+instanceOf,"isPrototypeOf,constructorName,inherit,typeOf"
+INT8_MAX,"INT8_MIN"
+INT8_MIN,"INT8_MAX"
+INT8_NUM_BYTES,"INT16_NUM_BYTES,INT32_NUM_BYTES,UINT8_NUM_BYTES"
+Int8Array,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+INT16_MAX,"INT16_MIN"
+INT16_MIN,"INT16_MAX"
+INT16_NUM_BYTES,"INT32_NUM_BYTES,INT8_NUM_BYTES,UINT16_NUM_BYTES"
+Int16Array,"ArrayBuffer,Float32Array,Float64Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+INT32_MAX,"INT32_MIN"
+INT32_MIN,"INT32_MAX"
+INT32_NUM_BYTES,"INT16_NUM_BYTES,INT8_NUM_BYTES,UINT32_NUM_BYTES"
+Int32Array,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int8Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+IS_BIG_ENDIAN,"IS_LITTLE_ENDIAN"
+IS_BROWSER,""
+IS_DARWIN,""
+IS_ELECTRON,"IS_ELECTRON_MAIN,IS_ELECTRON_RENDERER"
+IS_ELECTRON_MAIN,"IS_ELECTRON,IS_ELECTRON_RENDERER"
+IS_ELECTRON_RENDERER,"IS_ELECTRON,IS_ELECTRON_MAIN"
+IS_LITTLE_ENDIAN,"IS_BIG_ENDIAN"
+IS_NODE,""
+IS_WEB_WORKER,""
+IS_WINDOWS,""
+isAbsolutePath,"isRelativePath"
+isAccessorProperty,"hasOwnProp,isAccessorPropertyIn,isDataProperty"
+isAccessorPropertyIn,"hasProp,isAccessorProperty,isDataPropertyIn"
+isAlphagram,"isAnagram"
+isAlphaNumeric,"isDigitString"
+isAnagram,"isAlphagram"
+isArguments,""
+isArray,"isArrayLike"
+isArrayArray,""
+isArrayBuffer,"isSharedArrayBuffer,isTypedArray"
+isArrayLength,"isArray"
+isArrayLike,"isArray,isArrayLikeObject"
+isArrayLikeObject,"isArray,isArrayLike"
+isASCII,"isString"
+isBetween,"isBetweenArray"
+isBetweenArray,"isBetween"
+isBinaryString,"isString"
+isBoolean,""
+isBooleanArray,""
+isBoxedPrimitive,"isPrimitive"
+isBuffer,""
+isCapitalized,"isString"
+isCentrosymmetricMatrix,"isMatrixLike,isSquareMatrix,isSymmetricMatrix"
+isCircular,"isCircularArray,isCircularPlainObject"
+isCircularArray,"isCircular,isCircularPlainObject"
+isCircularPlainObject,"isCircular,isCircularArray"
+isCollection,"isArrayLike"
+isComplex,"isComplex64,isComplex128"
+isComplex64,"isComplex,isComplex128"
+isComplex64Array,"isComplex,isComplex64,isComplex128Array,isComplexTypedArray"
+isComplex128,"isComplex,isComplex64"
+isComplex128Array,"isComplex,isComplex128,isComplex64Array,isComplexTypedArray"
+isComplexLike,"isComplex,isComplex64,isComplex128"
+isComplexTypedArray,"isComplex,isComplex64Array,isComplex128Array"
+isConfigurableProperty,"isConfigurablePropertyIn,isEnumerableProperty,isReadableProperty,isWritableProperty"
+isConfigurablePropertyIn,"isConfigurableProperty,isEnumerablePropertyIn,isReadablePropertyIn,isWritablePropertyIn"
+isDataProperty,"hasOwnProp,isAccessorProperty,isDataPropertyIn"
+isDataPropertyIn,"hasProp,isAccessorPropertyIn,isDataProperty"
+isDateObject,""
+isDigitString,"isHexString,isString"
+isEmailAddress,""
+isEmptyArray,"isArray"
+isEmptyObject,"isObject,isPlainObject"
+isEmptyString,"isString"
+isEnumerableProperty,"isConfigurableProperty,isEnumerablePropertyIn,isNonEnumerableProperty,isReadableProperty,isWritableProperty"
+isEnumerablePropertyIn,"isConfigurablePropertyIn,isEnumerableProperty,isNonEnumerablePropertyIn,isReadablePropertyIn,isWritablePropertyIn"
+isError,""
+isEvalError,"isError"
+isEven,"isOdd"
+isFalsy,"isFalsyArray,isTruthy"
+isFalsyArray,"isFalsy,isTruthyArray"
+isFinite,"isFiniteArray,isInfinite"
+isFiniteArray,"isFinite,isInfinite"
+isFloat32Array,"isFloat64Array"
+isFloat64Array,"isFloat32Array"
+isFunction,""
+isFunctionArray,"isArray"
+isGeneratorObject,"hasGeneratorSupport,isGeneratorObjectLike"
+isGeneratorObjectLike,"hasGeneratorSupport,isGeneratorObject"
+isHexString,"isString"
+isInfinite,"isFinite"
+isInheritedProperty,"hasOwnProp,hasProp"
+isInt8Array,"isInt16Array,isInt32Array"
+isInt16Array,"isInt32Array,isInt8Array"
+isInt32Array,"isInt16Array,isInt8Array"
+isInteger,"isNumber"
+isIntegerArray,"isArray"
+isIterableLike,"isIteratorLike"
+isIteratorLike,"isIterableLike"
+isJSON,""
+isLeapYear,""
+isLowercase,"isString,isUppercase"
+isMatrixLike,"isArray,isArrayLike,isndarrayLike,isTypedArrayLike,isVectorLike"
+isMethod,"hasOwnProp,isFunction,isMethodIn"
+isMethodIn,"hasProp,isFunction,isMethod"
+isNamedTypedTupleLike,"namedtypedtuple"
+isnan,"isNumber"
+isNaNArray,"isnan"
+isNativeFunction,"isFunction"
+isndarrayLike,"isArray,isArrayLike,isMatrixLike,isTypedArrayLike,isVectorLike"
+isNegativeInteger,"isInteger"
+isNegativeIntegerArray,"isArray"
+isNegativeNumber,"isNumber"
+isNegativeNumberArray,"isArray"
+isNegativeZero,"isNumber,isPositiveZero"
+isNodeBuiltin,""
+isNodeDuplexStreamLike,"isNodeStreamLike"
+isNodeReadableStreamLike,"isNodeStreamLike"
+isNodeREPL,""
+isNodeStreamLike,""
+isNodeTransformStreamLike,"isNodeStreamLike"
+isNodeWritableStreamLike,"isNodeStreamLike"
+isNonConfigurableProperty,"isConfigurableProperty,isEnumerableProperty,isNonConfigurablePropertyIn,isNonEnumerableProperty,isReadableProperty,isWritableProperty"
+isNonConfigurablePropertyIn,"isConfigurablePropertyIn,isEnumerablePropertyIn,isNonConfigurableProperty,isNonEnumerablePropertyIn,isReadablePropertyIn,isWritablePropertyIn"
+isNonEnumerableProperty,"isConfigurableProperty,isEnumerableProperty,isNonConfigurableProperty,isNonEnumerablePropertyIn,isReadableProperty,isWritableProperty"
+isNonEnumerablePropertyIn,"isConfigurablePropertyIn,isEnumerablePropertyIn,isNonConfigurablePropertyIn,isNonEnumerableProperty,isReadablePropertyIn,isWritablePropertyIn"
+isNonNegativeInteger,"isInteger"
+isNonNegativeIntegerArray,"isArray"
+isNonNegativeNumber,"isNumber"
+isNonNegativeNumberArray,"isArray"
+isNonPositiveInteger,"isInteger"
+isNonPositiveIntegerArray,"isArray"
+isNonPositiveNumber,"isNumber"
+isNonPositiveNumberArray,"isArray"
+isNonSymmetricMatrix,"isMatrixLike,isSquareMatrix,isSymmetricMatrix"
+isNull,"isUndefined,isUndefinedOrNull"
+isNullArray,"isArray,isNull"
+isNumber,""
+isNumberArray,"isArray,isNumber,isNumericArray"
+isNumericArray,"isArray,isNumberArray,isTypedArray"
+isObject,"isObjectLike,isPlainObject"
+isObjectArray,"isArray,isObject"
+isObjectLike,"isObject,isPlainObject"
+isOdd,"isEven"
+isoWeeksInYear,""
+isPersymmetricMatrix,"isMatrixLike,isSquareMatrix,isSymmetricMatrix"
+isPlainObject,"isObject"
+isPlainObjectArray,"isArray,isPlainObject"
+isPositiveInteger,"isInteger"
+isPositiveIntegerArray,"isArray,isInteger,isPositiveInteger"
+isPositiveNumber,"isNumber"
+isPositiveNumberArray,"isArray,isNumber,isPositiveNumber"
+isPositiveZero,"isNumber,isNegativeZero"
+isPrimitive,"isBoxedPrimitive"
+isPrimitiveArray,"isArray,isPrimitive"
+isPRNGLike,""
+isProbability,"isNumber"
+isProbabilityArray,"isArray,isProbability"
+isPrototypeOf,"getPrototypeOf"
+isRangeError,"isError"
+isReadableProperty,"isReadOnlyProperty,isReadWriteProperty,isReadablePropertyIn,isWritableProperty"
+isReadablePropertyIn,"isReadOnlyPropertyIn,isReadWritePropertyIn,isReadableProperty,isWritablePropertyIn"
+isReadOnlyProperty,"isReadOnlyPropertyIn,isReadWriteProperty,isReadableProperty,isWritableProperty"
+isReadOnlyPropertyIn,"isReadOnlyProperty,isReadWritePropertyIn,isReadablePropertyIn,isWritablePropertyIn"
+isReadWriteProperty,"isReadOnlyProperty,isReadWritePropertyIn,isReadableProperty,isWritableProperty"
+isReadWritePropertyIn,"isReadOnlyPropertyIn,isReadWriteProperty,isReadablePropertyIn,isWritablePropertyIn"
+isReferenceError,"isError"
+isRegExp,""
+isRegExpString,"isRegExp"
+isRelativePath,"isAbsolutePath"
+isSafeInteger,"isInteger,isNumber"
+isSafeIntegerArray,"isArray,isSafeInteger"
+isSameValue,"isSameValueZero,isStrictEqual"
+isSameValueZero,"isSameValue,isStrictEqual"
+isSharedArrayBuffer,"isArrayBuffer,isTypedArray"
+isSkewCentrosymmetricMatrix,"isCentrosymmetricMatrix,isMatrixLike,isSkewSymmetricMatrix"
+isSkewPersymmetricMatrix,"isMatrixLike,isPersymmetricMatrix,isSkewSymmetricMatrix"
+isSkewSymmetricMatrix,"isMatrixLike,isSkewSymmetricMatrix,isSquareMatrix"
+isSquareMatrix,"isMatrixLike,isSymmetricMatrix"
+isStrictEqual,"isSameValue"
+isString,""
+isStringArray,"isArray,isString"
+isSymbol,""
+isSymbolArray,"isArray,isSymbol"
+isSymmetricMatrix,"isMatrixLike,isNonSymmetricMatrix,isSquareMatrix"
+isSyntaxError,"isError"
+isTruthy,"isFalsy"
+isTruthyArray,"isFalsyArray,isTruthy"
+isTypedArray,"isArray,isTypedArrayLike"
+isTypedArrayLength,"isArrayLength,isTypedArray"
+isTypedArrayLike,"isTypedArray"
+isTypeError,"isError"
+isUint8Array,"isTypedArray,isUint16Array,isUint32Array"
+isUint8ClampedArray,"isTypedArray,isUint8Array"
+isUint16Array,"isTypedArray,isUint32Array,isUint8Array"
+isUint32Array,"isTypedArray,isUint16Array,isUint8Array"
+isUNCPath,""
+isUndefined,"isNull,isUndefinedOrNull"
+isUndefinedOrNull,"isNull,isUndefined"
+isUnityProbabilityArray,"isProbability,isProbabilityArray"
+isUppercase,"isLowercase,isString"
+isURI,""
+isURIError,"isError"
+isVectorLike,"isArray,isArrayLike,isMatrixLike,isndarrayLike,isTypedArrayLike"
+isWhitespace,"RE_WHITESPACE"
+isWritableProperty,"isReadableProperty,isReadWriteProperty,isWritablePropertyIn,isWriteOnlyProperty"
+isWritablePropertyIn,"isReadablePropertyIn,isReadWritePropertyIn,isWritableProperty,isWriteOnlyPropertyIn"
+isWriteOnlyProperty,"isReadOnlyProperty,isReadWriteProperty,isWritableProperty,isWriteOnlyPropertyIn"
+isWriteOnlyPropertyIn,"isReadOnlyPropertyIn,isReadWritePropertyIn,isWritablePropertyIn,isWriteOnlyProperty"
+iterAdd,"iterDivide,iterMultiply,iterSubtract"
+iterAdvance,"iterHead,iterSlice"
+iterAny,"iterAnyBy,iterEvery,iterForEach,iterNone,iterSome"
+iterAnyBy,"iterAny,iterEveryBy,iterForEach,iterNoneBy,iterSomeBy"
+iterator2array,"array2iterator,iterator2arrayview"
+iterator2arrayview,"iterator2array,arrayview2iterator,iterator2arrayviewRight"
+iterator2arrayviewRight,"iterator2array,arrayview2iteratorRight,iterator2arrayview"
+iteratorStream,"arrayStream"
+IteratorSymbol,"Symbol"
+iterawgn,"iterawln,iterawun"
+iterawln,"iterawgn,iterawun"
+iterawun,"iterawgn,iterawln"
+iterBartlettHannPulse,"iterBartlettPulse,iterHannPulse,iterPulse,iterTriangleWave"
+iterBartlettPulse,"iterBartlettHannPulse,iterPulse,iterTriangleWave"
+iterConcat,""
+iterConstant,"constantFunction"
+iterCosineWave,"iterPulse,iterSawtoothWave,iterSineWave,iterSquareWave,iterTriangleWave"
+iterCounter,"iterLength"
+itercugmean,"itercuhmean,itercumean"
+itercuhmean,"itercugmean,itercumean"
+itercumax,"itercumidrange,itercumin,itercurange,itermax"
+itercumaxabs,"itercumax,itercuminabs,itermaxabs"
+itercumean,"itercumidrange,itercusum,itermean"
+itercumeanabs,"itercumean,itercumeanabs2,itercusumabs,itermeanabs"
+itercumeanabs2,"itercumean,itercumeanabs,itercusumabs2,itermeanabs2"
+itercumidrange,"itercumean,itercumax,itercumin,itercurange,itermidrange"
+itercumin,"itercumax,itercumidrange,itercurange,itermin"
+itercuminabs,"itercumaxabs,itercumin,iterminabs"
+itercuprod,"itercusum,iterprod"
+itercurange,"itercumax,itercumean,itercumin,iterrange"
+itercusum,"itercumean,itersum,itercuprod"
+itercusumabs,"itercumeanabs,itercusum,itersumabs"
+itercusumabs2,"itercumeanabs2,itercusumabs,itersumabs2"
+iterDedupe,"iterDedupeBy,iterUnique"
+iterDedupeBy,"iterDedupe,iterUnique"
+iterDiracComb,"iterPulse"
+iterDivide,"iterAdd,iterDivide,iterMultiply"
+iterEmpty,"iterConstant"
+iterEvery,"iterAny,iterEveryBy,iterForEach,iterNone,iterSome"
+iterEveryBy,"iterAnyBy,iterEvery,iterForEach,iterNoneBy,iterSomeBy"
+iterFibonacci,"base.fibonacci,iterNonFibonacci"
+iterFill,""
+iterFilter,"iterFilterMap,iterMap,iterReject"
+iterFilterMap,"iterFilter,iterMap"
+iterFirst,"iterHead,iterLast,iterNth"
+iterFlatTopPulse,"iterPulse"
+iterFlow,"iterPipeline"
+iterForEach,"iterMap"
+iterHannPulse,"iterBartlettHannPulse,iterPulse,iterSineWave"
+iterHead,"iterFirst,iterSlice"
+iterIntersection,"iterIntersectionByHash,iterUnion,iterUnique"
+iterIntersectionByHash,"iterIntersection,iterUniqueByHash"
+iterLanczosPulse,"iterPulse,iterPeriodicSinc"
+iterLast,"iterFirst,iterNth"
+iterLength,"iterCounter"
+iterMap,"iterFilter,iterFilterMap,iterForEach,iterReject"
+iterMapN,"iterMap"
+itermax,"itermidrange,itermin,itermmax,iterrange"
+itermaxabs,"itermax,iterminabs,itermmaxabs"
+itermean,"itermidrange,itermmean,iterstdev,itersum,itervariance"
+itermeanabs,"itermean,itermmeanabs,itersumabs"
+itermeanabs2,"itermean,itermeanabs,itermmeanabs2,itersumabs2"
+itermidrange,"itermean,itermax,itermin,iterrange"
+itermin,"itermax,itermidrange,itermmin,iterrange"
+iterminabs,"itermaxabs,itermin,itermminabs"
+itermmax,"itermax,itermmidrange,itermmin,itermrange"
+itermmaxabs,"itermaxabs,itermmax,itermminabs"
+itermmean,"itermean,itermsum"
+itermmeanabs,"itermeanabs,itermmean,itermsumabs"
+itermmeanabs2,"itermeanabs2,itermmeanabs,itermsumabs2"
+itermmidrange,"itermidrange,itermmean,itermmax,itermmin,itermrange"
+itermmin,"itermin,itermmax,itermmidrange,itermrange"
+itermminabs,"iterminabs,itermmaxabs,itermmin"
+iterMod,"iterDivide"
+itermprod,"itermsum,iterprod"
+itermrange,"itermmax,itermmean,itermmin,iterrange"
+itermsum,"itermmean,itersum"
+itermsumabs,"itermmeanabs,itermsum,itersum,itersumabs"
+itermsumabs2,"itermmeanabs2,itermsumabs,itersumabs,itersumabs2"
+iterMultiply,"iterAdd,iterDivide,iterSubtract"
+iterNone,"iterAny,iterEvery,iterForEach,iterNoneBy,iterSome"
+iterNoneBy,"iterAnyBy,iterEveryBy,iterForEach,iterNone,iterSomeBy"
+iterNonFibonacci,"base.nonfibonacci,iterFibonacci"
+iterNth,"iterFirst,iterLast"
+iterPeriodicSinc,"iterSineWave"
+iterPipeline,"iterFlow,iterThunk"
+iterPop,"iterPush,iterShift,iterSlice"
+iterprod,"itermprod,itersum"
+iterPulse,"iterSawtoothWave,iterSineWave,iterSquareWave,iterTriangleWave"
+iterPush,"iterConcat,iterUnshift"
+iterrange,"itermax,itermean,itermin,itermrange"
+iterReject,"iterFilter,iterMap"
+iterReplicate,"iterReplicateBy"
+iterReplicateBy,"iterReplicate"
+iterSawtoothWave,"iterPulse,iterSineWave,iterSquareWave,iterTriangleWave"
+iterShift,"iterPop,iterSlice,iterUnshift"
+iterSineWave,"iterCosineWave,iterPulse,iterSawtoothWave,iterSquareWave,iterTriangleWave"
+iterSlice,"iterFirst,iterHead"
+iterSome,"iterAny,iterEvery,iterForEach,iterNone,iterSomeBy"
+iterSomeBy,"iterAnyBy,iterEveryBy,iterForEach,iterNoneBy,iterSome"
+iterSquareWave,"iterPulse,iterSawtoothWave,iterSineWave,iterTriangleWave"
+iterstdev,"itermean,itervariance"
+iterSubtract,"iterAdd,iterDivide,iterMultiply"
+itersum,"itermean,itermsum,iterprod"
+itersumabs,"itermeanabs,itermsumabs,itersum"
+itersumabs2,"itermeanabs2,itermsumabs2,itersumabs"
+iterThunk,"iterPipeline"
+iterTriangleWave,"iterPulse,iterSawtoothWave,iterSineWave,iterSquareWave"
+iterUnion,"iterIntersection,iterUnique"
+iterUnique,"iterUniqueBy,iterUniqueByHash"
+iterUniqueBy,"iterUnique,iterUniqueByHash"
+iterUniqueByHash,"iterUnique,iterUniqueBy"
+iterUnshift,"iterConcat,iterPush,iterShift"
+itervariance,"itermean,iterstdev"
+joinStream,"splitStream"
+kde2d,""
+keyBy,"forEach"
+keyByRight,"forEachRight,keyBy"
+keysIn,"objectEntriesIn,objectKeys,objectValuesIn"
+kruskalTest,""
+kstest,""
+lda,""
+LinkedList,"DoublyLinkedList,Stack"
+linspace,"incrspace,logspace"
+LIU_NEGATIVE_OPINION_WORDS_EN,"LIU_POSITIVE_OPINION_WORDS_EN"
+LIU_POSITIVE_OPINION_WORDS_EN,"LIU_NEGATIVE_OPINION_WORDS_EN"
+LN_HALF,""
+LN_PI,"PI"
+LN_SQRT_TWO_PI,"PI"
+LN_TWO_PI,"TWO_PI"
+LN2,"LN10"
+LN10,"LN2"
+LOG2E,"E,LOG10E"
+LOG10E,"E,LOG2E"
+logspace,"incrspace,linspace"
+lowercase,"uncapitalize,uppercase"
+lowercaseKeys,"uncapitalizeKeys,uppercaseKeys"
+lowess,""
+lpad,"pad,rpad"
+ltrim,"trim,rtrim"
+MALE_FIRST_NAMES_EN,"FEMALE_FIRST_NAMES_EN"
+mapFun,"mapFunAsync"
+mapFunAsync,"mapFun"
+mapKeys,"mapValues"
+mapKeysAsync,"mapKeys,mapValuesAsync"
+mapValues,"mapKeys,omitBy,pickBy"
+mapValuesAsync,"mapKeysAsync,mapValues"
+MAX_ARRAY_LENGTH,"MAX_TYPED_ARRAY_LENGTH"
+MAX_TYPED_ARRAY_LENGTH,"MAX_ARRAY_LENGTH"
+memoize,""
+merge,"copy"
+MILLISECONDS_IN_DAY,""
+MILLISECONDS_IN_HOUR,""
+MILLISECONDS_IN_MINUTE,""
+MILLISECONDS_IN_SECOND,""
+MILLISECONDS_IN_WEEK,""
+MINARD_NAPOLEONS_MARCH,""
+MINUTES_IN_DAY,""
+MINUTES_IN_HOUR,""
+MINUTES_IN_WEEK,""
+minutesInMonth,"minutesInYear"
+minutesInYear,"minutesInMonth"
+MOBY_DICK,""
+MONTH_NAMES_EN,""
+MONTHS_IN_YEAR,""
+moveProperty,""
+namedtypedtuple,"typedarray"
+nativeClass,"constructorName,typeOf"
+ndarray,"array"
+ndarrayCastingModes,"array,ndarray"
+ndarrayDataTypes,"arrayDataTypes,array,ndarray,typedarrayDataTypes"
+ndarrayIndexModes,"array,ndarray"
+ndarrayMemoized,"array,ndarray"
+ndarrayMinDataType,"ndarrayDataTypes,ndarrayPromotionRules,ndarraySafeCasts"
+ndarrayNextDataType,"ndarrayDataTypes,ndarrayPromotionRules,ndarraySafeCasts"
+ndarrayOrders,"array,ndarray"
+ndarrayPromotionRules,"ndarrayCastingModes,ndarrayDataTypes,ndarraySafeCasts"
+ndarraySafeCasts,"ndarrayCastingModes,ndarrayDataTypes,ndarraySameKindCasts"
+ndarraySameKindCasts,"ndarrayCastingModes,ndarrayDataTypes,ndarraySafeCasts"
+NIGHTINGALES_ROSE,""
+NINF,"FLOAT16_NINF,FLOAT32_NINF,PINF"
+NODE_VERSION,""
+none,"any,every,forEach,noneBy,some"
+noneBy,"anyBy,everyBy,forEach,none,noneByRight,someBy"
+noneByAsync,"anyByAsync,everyByAsync,forEachAsync,noneBy,noneByRightAsync,someByAsync"
+noneByRight,"anyByRight,everyByRight,forEachRight,none,noneBy,someByRight"
+noneByRightAsync,"anyByRightAsync,everyByRightAsync,forEachRightAsync,noneByAsync,noneByRight,someByRightAsync"
+nonEnumerableProperties,"enumerableProperties,inheritedNonEnumerableProperties,nonEnumerablePropertiesIn,properties"
+nonEnumerablePropertiesIn,"enumerablePropertiesIn,inheritedNonEnumerableProperties,nonEnumerableProperties,propertiesIn"
+nonEnumerablePropertyNames,"objectKeys,inheritedNonEnumerablePropertyNames,nonEnumerablePropertyNamesIn,nonEnumerablePropertySymbols,propertyNames"
+nonEnumerablePropertyNamesIn,"keysIn,inheritedNonEnumerablePropertyNames,nonEnumerablePropertyNames,propertyNamesIn"
+nonEnumerablePropertySymbols,"enumerablePropertySymbols,inheritedNonEnumerablePropertySymbols,nonEnumerablePropertyNames,nonEnumerablePropertySymbolsIn,propertySymbols"
+nonEnumerablePropertySymbolsIn,"enumerablePropertySymbolsIn,inheritedNonEnumerablePropertySymbols,nonEnumerablePropertyNamesIn,nonEnumerablePropertySymbols,propertySymbolsIn"
+noop,""
+now,""
+NUM_CPUS,""
+Number,""
+objectEntries,"objectEntriesIn,objectFromEntries,objectKeys,objectValues"
+objectEntriesIn,"objectEntries,objectFromEntries,keysIn,objectValuesIn"
+objectFromEntries,"objectEntries"
+objectInverse,"objectInverseBy"
+objectInverseBy,"objectInverse"
+objectKeys,"objectEntries,keysIn,objectValues"
+objectValues,"objectEntries,objectKeys"
+objectValuesIn,"objectEntriesIn,keysIn,objectValues"
+omit,"omitBy"
+omitBy,"omit"
+onlineBinaryClassification,"onlineSGDRegression"
+onlineSGDRegression,"onlineBinaryClassification"
+openURL,""
+PACE_BOSTON_HOUSE_PRICES,"HARRISON_BOSTON_HOUSE_PRICES,HARRISON_BOSTON_HOUSE_PRICES_CORRECTED"
+pad,"lpad,rpad"
+papply,"papplyRight"
+papplyRight,"papply"
+parallel,""
+parseJSON,""
+PATH_DELIMITER,"PATH_DELIMITER_POSIX,PATH_DELIMITER_WIN32"
+PATH_DELIMITER_POSIX,"PATH_DELIMITER,PATH_DELIMITER_WIN32"
+PATH_DELIMITER_WIN32,"PATH_DELIMITER,PATH_DELIMITER_POSIX"
+PATH_SEP,"PATH_SEP_POSIX,PATH_SEP_WIN32"
+PATH_SEP_POSIX,"PATH_SEP,PATH_SEP_WIN32"
+PATH_SEP_WIN32,"PATH_SEP,PATH_SEP_POSIX"
+pcorrtest,""
+percentEncode,""
+PHI,""
+PI,"TWO_PI"
+PI_SQUARED,"PI"
+pick,"pickBy"
+pickBy,"pick"
+PINF,"NINF"
+pkg2alias,"alias2pkg,aliases,pkg2related"
+pkg2related,"alias2related,aliases,pkg2alias"
+PLATFORM,"ARCH"
+plot,"Plot"
+Plot,"plot"
+pluck,"deepPluck,pick"
+pop,"push,shift,unshift"
+prepend,"append,unshift"
+properties,"defineProperties,inheritedProperties,propertiesIn,propertyNames,propertySymbols"
+propertiesIn,"defineProperties,inheritedProperties,properties,propertyNamesIn,propertySymbolsIn"
+propertyDescriptor,"hasOwnProp,defineProperty,propertyDescriptorIn,propertyDescriptors"
+propertyDescriptorIn,"hasProp,defineProperty,propertyDescriptor,propertyDescriptorsIn"
+propertyDescriptors,"defineProperty,defineProperties,propertyDescriptor,propertyDescriptorsIn,propertyNames,propertySymbols"
+propertyDescriptorsIn,"defineProperties,propertyDescriptorIn,propertyDescriptors,propertyNamesIn,propertySymbolsIn"
+propertyNames,"objectKeys,nonEnumerablePropertyNames,propertyNamesIn,propertySymbols"
+propertyNamesIn,"objectKeys,nonEnumerablePropertyNamesIn,propertyNames,propertySymbolsIn"
+propertySymbols,"propertyNames,propertySymbolsIn"
+propertySymbolsIn,"propertyNamesIn,propertySymbols"
+Proxy,""
+push,"pop,shift,unshift"
+quarterOfYear,"dayOfYear"
+random.iterators.arcsine,"base.random.arcsine"
+random.iterators.bernoulli,"base.random.bernoulli"
+random.iterators.beta,"base.random.beta"
+random.iterators.betaprime,"base.random.betaprime"
+random.iterators.binomial,"base.random.binomial"
+random.iterators.boxMuller,"base.random.boxMuller"
+random.iterators.cauchy,"base.random.cauchy"
+random.iterators.chi,"base.random.chi"
+random.iterators.chisquare,"base.random.chisquare"
+random.iterators.cosine,"base.random.cosine"
+random.iterators.discreteUniform,"base.random.discreteUniform"
+random.iterators.erlang,"base.random.erlang"
+random.iterators.exponential,"base.random.exponential"
+random.iterators.f,"base.random.f"
+random.iterators.frechet,"base.random.frechet"
+random.iterators.gamma,"base.random.gamma"
+random.iterators.geometric,"base.random.geometric"
+random.iterators.gumbel,"base.random.gumbel"
+random.iterators.hypergeometric,"base.random.hypergeometric"
+random.iterators.improvedZiggurat,"base.random.improvedZiggurat"
+random.iterators.invgamma,"base.random.invgamma"
+random.iterators.kumaraswamy,"base.random.kumaraswamy"
+random.iterators.laplace,"base.random.laplace"
+random.iterators.levy,"base.random.levy"
+random.iterators.logistic,"base.random.logistic"
+random.iterators.lognormal,"base.random.lognormal"
+random.iterators.minstd,"base.random.minstd,random.iterators.minstdShuffle,random.iterators.mt19937,random.iterators.randi,random.iterators.randu"
+random.iterators.minstdShuffle,"base.random.minstdShuffle,random.iterators.minstd,random.iterators.mt19937,random.iterators.randi,random.iterators.randu"
+random.iterators.mt19937,"base.random.mt19937,random.iterators.minstd,random.iterators.minstdShuffle,random.iterators.randi,random.iterators.randu"
+random.iterators.negativeBinomial,"base.random.negativeBinomial"
+random.iterators.normal,"base.random.normal"
+random.iterators.pareto1,"base.random.pareto1"
+random.iterators.poisson,"base.random.poisson"
+random.iterators.randi,"base.random.randi,random.iterators.randu"
+random.iterators.randn,"base.random.randn"
+random.iterators.randu,"base.random.randu,random.iterators.randi"
+random.iterators.rayleigh,"base.random.rayleigh"
+random.iterators.t,"base.random.t"
+random.iterators.triangular,"base.random.triangular"
+random.iterators.uniform,"base.random.uniform"
+random.iterators.weibull,"base.random.weibull"
+random.streams.arcsine,"base.random.arcsine,random.iterators.arcsine"
+random.streams.bernoulli,"base.random.bernoulli,random.iterators.bernoulli"
+random.streams.beta,"base.random.beta,random.iterators.beta"
+random.streams.betaprime,"base.random.betaprime,random.iterators.betaprime"
+random.streams.binomial,"base.random.binomial,random.iterators.binomial"
+random.streams.boxMuller,"base.random.boxMuller,random.iterators.boxMuller,random.streams.improvedZiggurat,random.streams.randn"
+random.streams.cauchy,"base.random.cauchy,random.iterators.cauchy"
+random.streams.chi,"base.random.chi,random.iterators.chi"
+random.streams.chisquare,"base.random.chisquare,random.iterators.chisquare"
+random.streams.cosine,"base.random.cosine,random.iterators.cosine"
+random.streams.discreteUniform,"base.random.discreteUniform,random.iterators.discreteUniform"
+random.streams.erlang,"base.random.erlang,random.iterators.erlang"
+random.streams.exponential,"base.random.exponential,random.iterators.exponential"
+random.streams.f,"base.random.f,random.iterators.f"
+random.streams.gamma,"base.random.gamma,random.iterators.gamma"
+random.streams.geometric,"base.random.geometric,random.iterators.geometric"
+random.streams.gumbel,"base.random.gumbel,random.iterators.gumbel"
+random.streams.improvedZiggurat,"base.random.improvedZiggurat,random.iterators.improvedZiggurat,random.streams.boxMuller,random.streams.randn"
+random.streams.invgamma,"base.random.invgamma,random.iterators.invgamma"
+random.streams.kumaraswamy,"base.random.kumaraswamy,random.iterators.kumaraswamy"
+random.streams.laplace,"base.random.laplace,random.iterators.laplace"
+random.streams.levy,"base.random.levy,random.iterators.levy"
+random.streams.logistic,"base.random.logistic,random.iterators.logistic"
+random.streams.lognormal,"base.random.lognormal,random.iterators.lognormal"
+random.streams.minstd,"base.random.minstd,random.iterators.minstd,random.streams.minstdShuffle,random.streams.mt19937,random.streams.randi,random.streams.randu"
+random.streams.minstdShuffle,"base.random.minstdShuffle,random.iterators.minstdShuffle,random.streams.minstd,random.streams.mt19937,random.streams.randi,random.streams.randu"
+random.streams.mt19937,"base.random.mt19937,random.iterators.mt19937,random.streams.minstd,random.streams.minstdShuffle,random.streams.randi,random.streams.randu"
+random.streams.negativeBinomial,"base.random.negativeBinomial,random.iterators.negativeBinomial"
+random.streams.normal,"base.random.normal,random.iterators.normal"
+random.streams.pareto1,"base.random.pareto1,random.iterators.pareto1"
+random.streams.poisson,"base.random.poisson,random.iterators.poisson"
+random.streams.randi,"base.random.randi,random.iterators.randi,random.streams.randu"
+random.streams.randn,"base.random.randn,random.iterators.randn,random.streams.boxMuller,random.streams.improvedZiggurat"
+random.streams.randu,"base.random.randu,random.iterators.randu,random.streams.randi"
+random.streams.rayleigh,"base.random.rayleigh,random.iterators.rayleigh"
+random.streams.t,"base.random.t,random.iterators.t"
+random.streams.uniform,"base.random.uniform,random.iterators.uniform"
+random.streams.weibull,"base.random.weibull,random.iterators.weibull"
+ranks,""
+RE_BASENAME,"RE_BASENAME_POSIX,RE_BASENAME_WINDOWS"
+RE_BASENAME_POSIX,"RE_BASENAME,RE_BASENAME_WINDOWS"
+RE_BASENAME_WINDOWS,"RE_BASENAME,RE_BASENAME_POSIX"
+RE_COLOR_HEXADECIMAL,""
+RE_DECIMAL_NUMBER,""
+RE_DIRNAME,"RE_DIRNAME_POSIX,RE_DIRNAME_WINDOWS,dirname"
+RE_DIRNAME_POSIX,"RE_DIRNAME,RE_DIRNAME_WINDOWS,dirname"
+RE_DIRNAME_WINDOWS,"RE_DIRNAME,RE_DIRNAME_POSIX,dirname"
+RE_EOL,""
+RE_EXTENDED_LENGTH_PATH,""
+RE_EXTNAME,"RE_EXTNAME_POSIX,RE_EXTNAME_WINDOWS,extname"
+RE_EXTNAME_POSIX,"RE_EXTNAME,RE_EXTNAME_WINDOWS,extname"
+RE_EXTNAME_WINDOWS,"RE_EXTNAME,RE_EXTNAME_POSIX,extname"
+RE_FILENAME,"RE_FILENAME_POSIX,RE_FILENAME_WINDOWS"
+RE_FILENAME_POSIX,"RE_FILENAME,RE_FILENAME_WINDOWS"
+RE_FILENAME_WINDOWS,"RE_FILENAME,RE_FILENAME_POSIX"
+RE_FUNCTION_NAME,"functionName"
+RE_NATIVE_FUNCTION,"RE_FUNCTION_NAME,functionName"
+RE_REGEXP,"reFromString"
+RE_UNC_PATH,"isUNCPath"
+RE_UTF16_SURROGATE_PAIR,"RE_UTF16_UNPAIRED_SURROGATE"
+RE_UTF16_UNPAIRED_SURROGATE,"RE_UTF16_SURROGATE_PAIR"
+RE_WHITESPACE,"isWhitespace"
+readDir,"exists,readFile"
+readFile,"exists,readDir,readJSON,writeFile"
+readFileList,""
+readJSON,"readFile"
+readWASM,"readFile"
+real,"imag,reim"
+realmax,"realmin,typemax"
+realmin,"realmax,typemin"
+reduce,"forEach,reduceAsync,reduceRight"
+reduceAsync,"forEachAsync,reduce,reduceRightAsync"
+reduceRight,"forEachRight,reduce,reduceRightAsync"
+reduceRightAsync,"forEachRightAsync,reduceAsync,reduceRight"
+reFromString,""
+reim,"imag,real"
+removeFirst,"removeLast"
+removeLast,"removeFirst"
+removePunctuation,""
+removeUTF8BOM,""
+removeWords,""
+rename,"exists,readFile,writeFile,unlink"
+reorderArguments,"reverseArguments"
+repeat,"pad"
+replace,""
+rescape,""
+resolveParentPath,""
+reverseArguments,"reorderArguments"
+reverseString,""
+reviveBasePRNG,""
+reviveBuffer,"buffer2json"
+reviveComplex,"Complex128,Complex64,reviveComplex128,reviveComplex64"
+reviveComplex64,"Complex64,reviveComplex128,reviveComplex"
+reviveComplex128,"Complex128,reviveComplex64,reviveComplex"
+reviveError,"error2json"
+reviveTypedArray,"typedarray2json"
+rpad,"lpad,pad"
+rtrim,"ltrim,trim"
+safeintmax,"safeintmin,realmax,typemax"
+safeintmin,"safeintmax,realmin,typemin"
+sample,""
+SAVOY_STOPWORDS_FIN,""
+SAVOY_STOPWORDS_FR,""
+SAVOY_STOPWORDS_GER,""
+SAVOY_STOPWORDS_IT,""
+SAVOY_STOPWORDS_POR,""
+SAVOY_STOPWORDS_SP,""
+SAVOY_STOPWORDS_SWE,""
+SECONDS_IN_DAY,""
+SECONDS_IN_HOUR,""
+SECONDS_IN_MINUTE,""
+SECONDS_IN_WEEK,""
+secondsInMonth,"secondsInYear"
+secondsInYear,"secondsInMonth"
+setConfigurableReadOnly,"setConfigurableReadOnlyAccessor,setConfigurableReadWriteAccessor,defineProperty,setReadOnly"
+setConfigurableReadOnlyAccessor,"setConfigurableReadOnly,setConfigurableReadWriteAccessor,setConfigurableWriteOnlyAccessor,defineProperty,setReadOnlyAccessor"
+setConfigurableReadWriteAccessor,"setConfigurableReadOnly,setConfigurableReadOnlyAccessor,setConfigurableWriteOnlyAccessor,defineProperty,setReadWriteAccessor"
+setConfigurableWriteOnlyAccessor,"setConfigurableReadOnly,setConfigurableReadOnlyAccessor,setConfigurableReadWriteAccessor,defineProperty,setWriteOnlyAccessor"
+setMemoizedReadOnly,"defineMemoizedProperty,setReadOnly"
+setNonEnumerableProperty,"setNonEnumerableReadOnlyAccessor,setNonEnumerableReadOnly,setNonEnumerableReadWriteAccessor,setNonEnumerableWriteOnlyAccessor,setReadOnly"
+setNonEnumerableReadOnly,"setNonEnumerableProperty,setNonEnumerableReadOnlyAccessor,setNonEnumerableReadWriteAccessor,setNonEnumerableWriteOnlyAccessor,setReadOnly"
+setNonEnumerableReadOnlyAccessor,"setNonEnumerableProperty,setNonEnumerableReadOnly,setNonEnumerableReadWriteAccessor,setNonEnumerableWriteOnlyAccessor,setReadOnlyAccessor"
+setNonEnumerableReadWriteAccessor,"setNonEnumerableProperty,setNonEnumerableReadOnlyAccessor,setNonEnumerableReadOnly,setNonEnumerableWriteOnlyAccessor,setReadWriteAccessor"
+setNonEnumerableWriteOnlyAccessor,"setNonEnumerableProperty,setNonEnumerableReadOnlyAccessor,setNonEnumerableReadOnly,setNonEnumerableReadWriteAccessor,setWriteOnlyAccessor"
+setReadOnly,"setReadOnlyAccessor,setReadWriteAccessor,setWriteOnlyAccessor"
+setReadOnlyAccessor,"setReadOnly,setReadWriteAccessor,setWriteOnlyAccessor"
+setReadWriteAccessor,"setReadOnly,setReadOnlyAccessor,setWriteOnlyAccessor"
+setWriteOnlyAccessor,"setReadOnly,setReadOnlyAccessor,setReadWriteAccessor"
+SharedArrayBuffer,"Buffer,ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+shift,"pop,push,unshift"
+shuffle,"sample"
+sizeOf,"realmax,typemax"
+some,"any,every,forEach,none,someBy"
+someBy,"anyBy,everyBy,forEach,noneBy,someByAsync,someByRight"
+someByAsync,"anyByAsync,everyByAsync,forEachAsync,noneByAsync,someBy,someByRightAsync"
+someByRight,"anyByRight,everyByRight,forEachRight,noneByRight,someBy,someByRightAsync"
+someByRightAsync,"anyByRightAsync,everyByRightAsync,forEachRightAsync,noneByRightAsync,someByAsync,someByRight"
+SOTU,""
+SPACHE_REVISED,""
+SPAM_ASSASSIN,""
+SparklineBase,"plot,Plot,UnicodeColumnChartSparkline,UnicodeLineChartSparkline,UnicodeTristateChartSparkline,UnicodeWinLossChartSparkline"
+sparsearray2iterator,"iterator2array,array2iterator,sparsearray2iteratorRight"
+sparsearray2iteratorRight,"iterator2array,array2iteratorRight,sparsearray2iterator"
+splitStream,"joinStream"
+SQRT_EPS,"EPS"
+SQRT_HALF,"LN_HALF"
+SQRT_HALF_PI,"PI"
+SQRT_PHI,"PHI"
+SQRT_PI,"PI"
+SQRT_THREE,""
+SQRT_TWO,"LN2"
+SQRT_TWO_PI,"TWO_PI"
+Stack,"FIFO"
+startcase,"lowercase,uppercase"
+startsWith,"endsWith"
+STOPWORDS_EN,""
+stridedarray2iterator,"iterator2array,array2iterator"
+stridedArrayStream,"arrayStream"
+string2buffer,"Buffer,array2buffer,arraybuffer2buffer,copyBuffer"
+sub2ind,"array,ndarray,ind2sub"
+SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK,"SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK"
+SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK,"SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK"
+Symbol,""
+tabulate,"countBy,groupBy,tabulateBy"
+tabulateBy,"countBy,groupBy,tabulate"
+tabulateByAsync,"countByAsync,groupByAsync,tabulateBy"
+tic,"toc"
+timeit,""
+tmpdir,"configdir,homedir"
+toc,"tic"
+tokenize,""
+transformStream,""
+trim,"ltrim,pad,rtrim"
+trycatch,"trycatchAsync,trythen"
+trycatchAsync,"trycatch,trythenAsync"
+tryFunction,""
+tryRequire,""
+trythen,"trycatch,trythenAsync"
+trythenAsync,"trycatchAsync,trythen"
+ttest,"ttest2"
+ttest2,"ttest"
+TWO_PI,"PI"
+typedarray,"Float64Array,Float32Array,Int32Array,Uint32Array,Int16Array,Uint16Array,Int8Array,Uint8Array,Uint8ClampedArray"
+typedarray2json,"reviveTypedArray"
+typedarrayComplexCtors,"arrayCtors,typedarrayCtors"
+typedarrayComplexDataTypes,"arrayDataTypes,typedarrayDataTypes,ndarrayDataTypes"
+typedarrayCtors,"arrayCtors"
+typedarrayDataTypes,"arrayDataTypes,ndarrayDataTypes"
+typedarraypool,"typedarray"
+typemax,"realmax,typemin"
+typemin,"realmin,typemax"
+typeOf,"constructorName,nativeClass"
+UINT8_MAX,"INT8_MAX"
+UINT8_NUM_BYTES,"INT8_NUM_BYTES,UINT16_NUM_BYTES,UINT32_NUM_BYTES"
+Uint8Array,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8ClampedArray"
+Uint8ClampedArray,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint32Array,Uint8Array"
+UINT16_MAX,"INT16_MAX"
+UINT16_NUM_BYTES,"INT16_NUM_BYTES,UINT32_NUM_BYTES,UINT8_NUM_BYTES"
+Uint16Array,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,Uint32Array,Uint8Array,Uint8ClampedArray"
+UINT32_MAX,"INT32_MAX"
+UINT32_NUM_BYTES,"INT32_NUM_BYTES,UINT16_NUM_BYTES,UINT8_NUM_BYTES"
+Uint32Array,"ArrayBuffer,Float32Array,Float64Array,Int16Array,Int32Array,Int8Array,Uint16Array,Uint8Array,Uint8ClampedArray"
+umask,""
+uncapitalize,"capitalize,lowercase"
+uncapitalizeKeys,"capitalizeKeys,lowercaseKeys"
+uncurry,"curry,uncurryRight"
+uncurryRight,"curry,curryRight,uncurry"
+UNICODE_MAX,"UNICODE_MAX_BMP"
+UNICODE_MAX_BMP,"UNICODE_MAX"
+UnicodeColumnChartSparkline,"plot,Plot,UnicodeSparkline,UnicodeLineChartSparkline,UnicodeTristateChartSparkline,UnicodeUpDownChartSparkline,UnicodeWinLossChartSparkline"
+UnicodeLineChartSparkline,"plot,Plot,UnicodeSparkline,UnicodeColumnChartSparkline,UnicodeTristateChartSparkline,UnicodeUpDownChartSparkline,UnicodeWinLossChartSparkline"
+UnicodeSparkline,"plot,Plot,UnicodeColumnChartSparkline,UnicodeLineChartSparkline,UnicodeTristateChartSparkline,UnicodeUpDownChartSparkline,UnicodeWinLossChartSparkline"
+UnicodeTristateChartSparkline,"plot,Plot,UnicodeSparkline,UnicodeColumnChartSparkline,UnicodeLineChartSparkline,UnicodeUpDownChartSparkline,UnicodeWinLossChartSparkline"
+UnicodeUpDownChartSparkline,"plot,Plot,UnicodeSparkline,UnicodeColumnChartSparkline,UnicodeLineChartSparkline,UnicodeTristateChartSparkline,UnicodeWinLossChartSparkline"
+UnicodeWinLossChartSparkline,"plot,Plot,UnicodeSparkline,UnicodeColumnChartSparkline,UnicodeLineChartSparkline,UnicodeTristateChartSparkline,UnicodeUpDownChartSparkline"
+unlink,"exists"
+unshift,"pop,push,shift"
+until,"doUntil,doWhile,untilAsync,untilEach,whilst"
+untilAsync,"doUntilAsync,doWhileAsync,until,whileAsync"
+untilEach,"untilEachRight,whileEach"
+untilEachRight,"untilEach,whileEachRight"
+unzip,"zip"
+uppercase,"capitalize,lowercase"
+uppercaseKeys,"capitalizeKeys,lowercaseKeys"
+US_STATES_ABBR,"US_STATES_CAPITALS,US_STATES_NAMES"
+US_STATES_CAPITALS,"US_STATES_ABBR,US_STATES_CAPITALS_NAMES,US_STATES_NAMES,US_STATES_NAMES_CAPITALS"
+US_STATES_CAPITALS_NAMES,"US_STATES_CAPITALS,US_STATES_NAMES,US_STATES_NAMES_CAPITALS"
+US_STATES_NAMES,"US_STATES_ABBR,US_STATES_CAPITALS,US_STATES_CAPITALS_NAMES,US_STATES_NAMES_CAPITALS"
+US_STATES_NAMES_CAPITALS,"US_STATES_CAPITALS,US_STATES_NAMES,US_STATES_NAMES_CAPITALS"
+utf16ToUTF8Array,""
+vartest,"bartlettTest"
+waterfall,""
+whileAsync,"doUntilAsync,doWhileAsync,untilAsync,whilst"
+whileEach,"untilEach,whileEachRight"
+whileEachRight,"whileEach,untilEachRight"
+whilst,"doUntil,doWhile,until,whileAsync,whileEach"
+writableProperties,"inheritedWritableProperties,writablePropertiesIn,properties"
+writablePropertiesIn,"inheritedWritableProperties,writableProperties,propertiesIn"
+writablePropertyNames,"inheritedWritablePropertyNames,writableProperties,writablePropertyNamesIn,writablePropertySymbols,propertyNames"
+writablePropertyNamesIn,"inheritedWritablePropertyNames,writablePropertiesIn,writablePropertyNames,writablePropertySymbolsIn,propertyNamesIn"
+writablePropertySymbols,"inheritedWritablePropertySymbols,writableProperties,writablePropertyNames,writablePropertySymbolsIn,propertySymbols"
+writablePropertySymbolsIn,"inheritedWritablePropertySymbols,writablePropertiesIn,writablePropertyNamesIn,writablePropertySymbols,propertySymbolsIn"
+writeFile,"exists,readFile"
+zip,"unzip"
+ztest,"ztest2"
+ztest2,"ztest"
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/data/data.json b/lib/node_modules/@stdlib/namespace/alias2related/data/data.json
new file mode 100644
index 000000000000..75134e9e44fa
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/data/data.json
@@ -0,0 +1 @@
+{"AFINN_96":["AFINN_111"],"AFINN_111":["AFINN_96"],"alias2pkg":["alias2related","aliases","pkg2alias"],"alias2related":["alias2pkg","aliases","pkg2related"],"aliases":["alias2pkg","alias2related","pkg2alias"],"allocUnsafe":["Buffer","array2buffer","arraybuffer2buffer","copyBuffer","string2buffer"],"anova1":[],"ANSCOMBES_QUARTET":[],"any":["anyBy","every","forEach","none","some"],"anyBy":["anyByAsync","anyByRight","everyBy","forEach","noneBy","someBy"],"anyByAsync":["anyBy","anyByRightAsync","everyByAsync","forEachAsync","noneByAsync","someByAsync"],"anyByRight":["anyBy","anyByRightAsync","everyByRight","forEachRight","noneByRight","someByRight"],"anyByRightAsync":["anyByAsync","anyByRight","everyByRightAsync","forEachRightAsync","noneByRightAsync","someByRightAsync"],"APERY":[],"append":["prepend","push"],"ARCH":["PLATFORM"],"argumentFunction":["constantFunction","identity"],"ARGV":["ENV"],"array":["ndarray"],"array2buffer":["Buffer","arraybuffer2buffer","copyBuffer","string2buffer"],"array2iterator":["iterator2array","circarray2iterator","array2iteratorRight","stridedarray2iterator"],"array2iteratorRight":["iterator2array","array2iterator"],"ArrayBuffer":["Buffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","SharedArrayBuffer","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"arraybuffer2buffer":["Buffer","array2buffer","copyBuffer","string2buffer"],"arrayCtors":["typedarrayCtors"],"arrayDataType":["arrayDataTypes"],"arrayDataTypes":["typedarrayDataTypes","ndarrayDataTypes"],"arrayMinDataType":["arrayDataTypes","arrayPromotionRules","arraySafeCasts"],"arrayNextDataType":["arrayDataType","arrayDataTypes"],"arrayPromotionRules":["arrayDataTypes","arraySafeCasts","ndarrayPromotionRules"],"arraySafeCasts":["convertArray","convertArraySame","arrayDataTypes","arraySameKindCasts","ndarraySafeCasts"],"arraySameKindCasts":["convertArray","convertArraySame","arrayDataTypes","arraySafeCasts","ndarraySameKindCasts"],"arrayShape":["ndarray"],"arrayStream":["circularArrayStream","iteratorStream","stridedArrayStream"],"arrayview2iterator":["iterator2array","array2iterator","stridedarray2iterator","arrayview2iteratorRight"],"arrayview2iteratorRight":["iterator2array","array2iteratorRight","stridedarray2iterator","arrayview2iterator"],"AsyncIteratorSymbol":["Symbol","IteratorSymbol"],"bartlettTest":["vartest"],"base.abs":["base.abs2"],"base.abs2":["base.abs"],"base.absdiff":["base.reldiff","base.epsdiff"],"base.absInt32":["base.abs"],"base.acos":["base.acosh","base.asin","base.atan"],"base.acosh":["base.acos","base.asinh","base.atanh"],"base.acoth":["base.acosh","base.asinh","base.atanh"],"base.acovercos":["base.acoversin","base.avercos","base.covercos","base.vercos"],"base.acoversin":["base.acovercos","base.aversin","base.coversin","base.versin"],"base.ahavercos":["base.ahaversin","base.havercos","base.vercos"],"base.ahaversin":["base.ahavercos","base.haversin","base.versin"],"base.asin":["base.acos","base.asinh","base.atan"],"base.asinh":["base.acosh","base.asin","base.atanh"],"base.atan":["base.acos","base.asin","base.atanh"],"base.atan2":["base.atan"],"base.atanh":["base.acosh","base.asinh","base.atan"],"base.avercos":["base.aversin","base.versin"],"base.aversin":["base.avercos","base.vercos"],"base.bernoulli":[],"base.besselj0":["base.besselj1","base.bessely0","base.bessely1"],"base.besselj1":["base.besselj0","base.bessely0","base.bessely1"],"base.bessely0":["base.besselj0","base.besselj1","base.bessely1"],"base.bessely1":["base.besselj0","base.besselj1","base.bessely0"],"base.beta":["base.betainc","base.betaincinv","base.betaln"],"base.betainc":["base.beta","base.betaincinv","base.betaln"],"base.betaincinv":["base.beta","base.betainc","base.betaln"],"base.betaln":["base.beta","base.betainc","base.betaincinv"],"base.binet":["base.fibonacci","base.negafibonacci"],"base.binomcoef":[],"base.binomcoefln":[],"base.boxcox":["base.boxcoxinv","base.boxcox1p","base.boxcox1pinv"],"base.boxcox1p":["base.boxcox","base.boxcox1pinv","base.boxcoxinv"],"base.boxcox1pinv":["base.boxcox","base.boxcox1p","base.boxcoxinv"],"base.boxcoxinv":["base.boxcox","base.boxcox1p","base.boxcox1pinv"],"base.cabs":["base.cabs2","base.abs"],"base.cabs2":["base.cabs","base.abs2"],"base.cadd":["base.cdiv","base.cmul","base.csub"],"base.cbrt":["base.pow","base.sqrt"],"base.cceil":["base.cceiln","base.cfloor","base.cround"],"base.cceiln":["base.cceil","base.cfloorn","base.croundn"],"base.ccis":[],"base.cdiv":["base.cadd","base.cmul","base.csub"],"base.ceil":["base.ceiln","base.floor","base.round"],"base.ceil2":["base.ceil","base.ceil10","base.floor2","base.round2"],"base.ceil10":["base.ceil","base.ceil2","base.floor10","base.round10"],"base.ceilb":["base.ceil","base.ceiln","base.floorb","base.roundb"],"base.ceiln":["base.ceil","base.ceilb","base.floorn","base.roundn"],"base.ceilsd":["base.ceil","base.floorsd","base.roundsd","base.truncsd"],"base.cexp":[],"base.cflipsign":["base.cneg","base.csignum"],"base.cfloor":["base.cceil","base.cfloorn","base.cround"],"base.cfloorn":["base.cceiln","base.cfloor","base.croundn"],"base.cinv":["base.cdiv"],"base.clamp":["base.wrap"],"base.cmul":["base.cadd","base.cdiv","base.csub"],"base.cneg":["base.cabs"],"base.continuedFraction":[],"base.copysign":["base.flipsign"],"base.cos":["base.cospi","base.cosm1","base.sin","base.tan"],"base.cosh":["base.cos","base.sinh","base.tanh"],"base.cosm1":["base.cos"],"base.cospi":["base.cos"],"base.covercos":["base.coversin","base.vercos"],"base.coversin":["base.covercos","base.versin"],"base.cphase":["base.cabs"],"base.cpolar":["base.cabs","base.cphase"],"base.cround":["base.cceil","base.cfloor","base.croundn"],"base.croundn":["base.cceiln","base.cfloorn","base.cround"],"base.csignum":["base.signum"],"base.csub":["base.cadd","base.cdiv","base.cmul"],"base.dasum":["base.daxpy","base.dcopy"],"base.daxpy":["base.dasum","base.dcopy"],"base.dcopy":["base.dasum","base.daxpy"],"base.deg2rad":["base.rad2deg"],"base.digamma":["base.trigamma","base.gamma"],"base.diracDelta":["base.kroneckerDelta"],"base.dists.arcsine.Arcsine":[],"base.dists.arcsine.cdf":[],"base.dists.arcsine.entropy":[],"base.dists.arcsine.kurtosis":[],"base.dists.arcsine.logcdf":[],"base.dists.arcsine.logpdf":[],"base.dists.arcsine.mean":[],"base.dists.arcsine.median":[],"base.dists.arcsine.mode":[],"base.dists.arcsine.pdf":[],"base.dists.arcsine.quantile":[],"base.dists.arcsine.skewness":[],"base.dists.arcsine.stdev":[],"base.dists.arcsine.variance":[],"base.dists.bernoulli.Bernoulli":[],"base.dists.bernoulli.cdf":[],"base.dists.bernoulli.entropy":[],"base.dists.bernoulli.kurtosis":[],"base.dists.bernoulli.mean":[],"base.dists.bernoulli.median":[],"base.dists.bernoulli.mgf":[],"base.dists.bernoulli.mode":[],"base.dists.bernoulli.pmf":[],"base.dists.bernoulli.quantile":[],"base.dists.bernoulli.skewness":[],"base.dists.bernoulli.stdev":[],"base.dists.bernoulli.variance":[],"base.dists.beta.Beta":[],"base.dists.beta.cdf":[],"base.dists.beta.entropy":[],"base.dists.beta.kurtosis":[],"base.dists.beta.logcdf":[],"base.dists.beta.logpdf":[],"base.dists.beta.mean":[],"base.dists.beta.median":[],"base.dists.beta.mgf":[],"base.dists.beta.mode":[],"base.dists.beta.pdf":[],"base.dists.beta.quantile":[],"base.dists.beta.skewness":[],"base.dists.beta.stdev":[],"base.dists.beta.variance":[],"base.dists.betaprime.BetaPrime":[],"base.dists.betaprime.cdf":[],"base.dists.betaprime.kurtosis":[],"base.dists.betaprime.logcdf":[],"base.dists.betaprime.logpdf":[],"base.dists.betaprime.mean":[],"base.dists.betaprime.mode":[],"base.dists.betaprime.pdf":[],"base.dists.betaprime.quantile":[],"base.dists.betaprime.skewness":[],"base.dists.betaprime.stdev":[],"base.dists.betaprime.variance":[],"base.dists.binomial.Binomial":[],"base.dists.binomial.cdf":[],"base.dists.binomial.entropy":[],"base.dists.binomial.kurtosis":[],"base.dists.binomial.logpmf":[],"base.dists.binomial.mean":[],"base.dists.binomial.median":[],"base.dists.binomial.mgf":[],"base.dists.binomial.mode":[],"base.dists.binomial.pmf":[],"base.dists.binomial.quantile":[],"base.dists.binomial.skewness":[],"base.dists.binomial.stdev":[],"base.dists.binomial.variance":[],"base.dists.cauchy.Cauchy":[],"base.dists.cauchy.cdf":[],"base.dists.cauchy.entropy":[],"base.dists.cauchy.logcdf":[],"base.dists.cauchy.logpdf":[],"base.dists.cauchy.median":[],"base.dists.cauchy.mode":[],"base.dists.cauchy.pdf":[],"base.dists.cauchy.quantile":[],"base.dists.chi.cdf":[],"base.dists.chi.Chi":[],"base.dists.chi.entropy":[],"base.dists.chi.kurtosis":[],"base.dists.chi.logpdf":[],"base.dists.chi.mean":[],"base.dists.chi.mode":[],"base.dists.chi.pdf":[],"base.dists.chi.quantile":[],"base.dists.chi.skewness":[],"base.dists.chi.stdev":[],"base.dists.chi.variance":[],"base.dists.chisquare.cdf":[],"base.dists.chisquare.ChiSquare":[],"base.dists.chisquare.entropy":[],"base.dists.chisquare.kurtosis":[],"base.dists.chisquare.logpdf":[],"base.dists.chisquare.mean":[],"base.dists.chisquare.mgf":[],"base.dists.chisquare.mode":[],"base.dists.chisquare.pdf":[],"base.dists.chisquare.quantile":[],"base.dists.chisquare.skewness":[],"base.dists.chisquare.stdev":[],"base.dists.chisquare.variance":[],"base.dists.cosine.cdf":[],"base.dists.cosine.Cosine":[],"base.dists.cosine.kurtosis":[],"base.dists.cosine.logcdf":[],"base.dists.cosine.logpdf":[],"base.dists.cosine.mean":[],"base.dists.cosine.median":[],"base.dists.cosine.mgf":[],"base.dists.cosine.mode":[],"base.dists.cosine.pdf":[],"base.dists.cosine.quantile":[],"base.dists.cosine.skewness":[],"base.dists.cosine.stdev":[],"base.dists.cosine.variance":[],"base.dists.degenerate.cdf":[],"base.dists.degenerate.Degenerate":[],"base.dists.degenerate.entropy":[],"base.dists.degenerate.logcdf":[],"base.dists.degenerate.logpdf":[],"base.dists.degenerate.logpmf":[],"base.dists.degenerate.mean":[],"base.dists.degenerate.median":[],"base.dists.degenerate.mgf":[],"base.dists.degenerate.mode":[],"base.dists.degenerate.pdf":[],"base.dists.degenerate.pmf":[],"base.dists.degenerate.quantile":[],"base.dists.degenerate.stdev":[],"base.dists.degenerate.variance":[],"base.dists.discreteUniform.cdf":[],"base.dists.discreteUniform.DiscreteUniform":[],"base.dists.discreteUniform.kurtosis":[],"base.dists.discreteUniform.logcdf":[],"base.dists.discreteUniform.logpmf":[],"base.dists.discreteUniform.mean":[],"base.dists.discreteUniform.median":[],"base.dists.discreteUniform.mgf":[],"base.dists.discreteUniform.pmf":[],"base.dists.discreteUniform.quantile":[],"base.dists.discreteUniform.skewness":[],"base.dists.discreteUniform.stdev":[],"base.dists.discreteUniform.variance":[],"base.dists.erlang.cdf":[],"base.dists.erlang.entropy":[],"base.dists.erlang.Erlang":[],"base.dists.erlang.kurtosis":[],"base.dists.erlang.logpdf":[],"base.dists.erlang.mean":[],"base.dists.erlang.mgf":[],"base.dists.erlang.mode":[],"base.dists.erlang.pdf":[],"base.dists.erlang.quantile":[],"base.dists.erlang.skewness":[],"base.dists.erlang.stdev":[],"base.dists.erlang.variance":[],"base.dists.exponential.cdf":[],"base.dists.exponential.entropy":[],"base.dists.exponential.Exponential":[],"base.dists.exponential.kurtosis":[],"base.dists.exponential.logcdf":[],"base.dists.exponential.logpdf":[],"base.dists.exponential.mean":[],"base.dists.exponential.median":[],"base.dists.exponential.mgf":[],"base.dists.exponential.mode":[],"base.dists.exponential.pdf":[],"base.dists.exponential.quantile":[],"base.dists.exponential.skewness":[],"base.dists.exponential.stdev":[],"base.dists.exponential.variance":[],"base.dists.f.cdf":[],"base.dists.f.entropy":[],"base.dists.f.F":[],"base.dists.f.kurtosis":[],"base.dists.f.mean":[],"base.dists.f.mode":[],"base.dists.f.pdf":[],"base.dists.f.quantile":[],"base.dists.f.skewness":[],"base.dists.f.stdev":[],"base.dists.f.variance":[],"base.dists.frechet.cdf":[],"base.dists.frechet.entropy":[],"base.dists.frechet.Frechet":[],"base.dists.frechet.kurtosis":[],"base.dists.frechet.logcdf":[],"base.dists.frechet.logpdf":[],"base.dists.frechet.mean":[],"base.dists.frechet.median":[],"base.dists.frechet.mode":[],"base.dists.frechet.pdf":[],"base.dists.frechet.quantile":[],"base.dists.frechet.skewness":[],"base.dists.frechet.stdev":[],"base.dists.frechet.variance":[],"base.dists.gamma.cdf":[],"base.dists.gamma.entropy":[],"base.dists.gamma.Gamma":[],"base.dists.gamma.kurtosis":[],"base.dists.gamma.logpdf":[],"base.dists.gamma.mean":[],"base.dists.gamma.mgf":[],"base.dists.gamma.mode":[],"base.dists.gamma.pdf":[],"base.dists.gamma.quantile":[],"base.dists.gamma.skewness":[],"base.dists.gamma.stdev":[],"base.dists.gamma.variance":[],"base.dists.geometric.cdf":[],"base.dists.geometric.entropy":[],"base.dists.geometric.Geometric":[],"base.dists.geometric.kurtosis":[],"base.dists.geometric.logcdf":[],"base.dists.geometric.logpmf":[],"base.dists.geometric.mean":[],"base.dists.geometric.median":[],"base.dists.geometric.mgf":[],"base.dists.geometric.mode":[],"base.dists.geometric.pmf":[],"base.dists.geometric.quantile":[],"base.dists.geometric.skewness":[],"base.dists.geometric.stdev":[],"base.dists.geometric.variance":[],"base.dists.gumbel.cdf":[],"base.dists.gumbel.entropy":[],"base.dists.gumbel.Gumbel":[],"base.dists.gumbel.kurtosis":[],"base.dists.gumbel.logcdf":[],"base.dists.gumbel.logpdf":[],"base.dists.gumbel.mean":[],"base.dists.gumbel.median":[],"base.dists.gumbel.mgf":[],"base.dists.gumbel.mode":[],"base.dists.gumbel.pdf":[],"base.dists.gumbel.quantile":[],"base.dists.gumbel.skewness":[],"base.dists.gumbel.stdev":[],"base.dists.gumbel.variance":[],"base.dists.hypergeometric.cdf":[],"base.dists.hypergeometric.Hypergeometric":[],"base.dists.hypergeometric.kurtosis":[],"base.dists.hypergeometric.logpmf":[],"base.dists.hypergeometric.mean":[],"base.dists.hypergeometric.mode":[],"base.dists.hypergeometric.pmf":[],"base.dists.hypergeometric.quantile":[],"base.dists.hypergeometric.skewness":[],"base.dists.hypergeometric.stdev":[],"base.dists.hypergeometric.variance":[],"base.dists.invgamma.cdf":[],"base.dists.invgamma.entropy":[],"base.dists.invgamma.InvGamma":[],"base.dists.invgamma.kurtosis":[],"base.dists.invgamma.logpdf":[],"base.dists.invgamma.mean":[],"base.dists.invgamma.mode":[],"base.dists.invgamma.pdf":[],"base.dists.invgamma.quantile":[],"base.dists.invgamma.skewness":[],"base.dists.invgamma.stdev":[],"base.dists.invgamma.variance":[],"base.dists.kumaraswamy.cdf":[],"base.dists.kumaraswamy.Kumaraswamy":[],"base.dists.kumaraswamy.kurtosis":[],"base.dists.kumaraswamy.logcdf":[],"base.dists.kumaraswamy.logpdf":[],"base.dists.kumaraswamy.mean":[],"base.dists.kumaraswamy.median":[],"base.dists.kumaraswamy.mode":[],"base.dists.kumaraswamy.pdf":[],"base.dists.kumaraswamy.quantile":[],"base.dists.kumaraswamy.skewness":[],"base.dists.kumaraswamy.stdev":[],"base.dists.kumaraswamy.variance":[],"base.dists.laplace.cdf":[],"base.dists.laplace.entropy":[],"base.dists.laplace.kurtosis":[],"base.dists.laplace.Laplace":[],"base.dists.laplace.logcdf":[],"base.dists.laplace.logpdf":[],"base.dists.laplace.mean":[],"base.dists.laplace.median":[],"base.dists.laplace.mgf":[],"base.dists.laplace.mode":[],"base.dists.laplace.pdf":[],"base.dists.laplace.quantile":[],"base.dists.laplace.skewness":[],"base.dists.laplace.stdev":[],"base.dists.laplace.variance":[],"base.dists.levy.cdf":[],"base.dists.levy.entropy":[],"base.dists.levy.Levy":[],"base.dists.levy.logcdf":[],"base.dists.levy.logpdf":[],"base.dists.levy.mean":[],"base.dists.levy.median":[],"base.dists.levy.mode":[],"base.dists.levy.pdf":[],"base.dists.levy.quantile":[],"base.dists.levy.stdev":[],"base.dists.levy.variance":[],"base.dists.logistic.cdf":[],"base.dists.logistic.entropy":[],"base.dists.logistic.kurtosis":[],"base.dists.logistic.logcdf":[],"base.dists.logistic.Logistic":[],"base.dists.logistic.logpdf":[],"base.dists.logistic.mean":[],"base.dists.logistic.median":[],"base.dists.logistic.mgf":[],"base.dists.logistic.mode":[],"base.dists.logistic.pdf":[],"base.dists.logistic.quantile":[],"base.dists.logistic.skewness":[],"base.dists.logistic.stdev":[],"base.dists.logistic.variance":[],"base.dists.lognormal.cdf":[],"base.dists.lognormal.entropy":[],"base.dists.lognormal.kurtosis":[],"base.dists.lognormal.LogNormal":[],"base.dists.lognormal.logpdf":[],"base.dists.lognormal.mean":[],"base.dists.lognormal.median":[],"base.dists.lognormal.mode":[],"base.dists.lognormal.pdf":[],"base.dists.lognormal.quantile":[],"base.dists.lognormal.skewness":[],"base.dists.lognormal.stdev":[],"base.dists.lognormal.variance":[],"base.dists.negativeBinomial.cdf":[],"base.dists.negativeBinomial.kurtosis":[],"base.dists.negativeBinomial.logpmf":[],"base.dists.negativeBinomial.mean":[],"base.dists.negativeBinomial.mgf":[],"base.dists.negativeBinomial.mode":[],"base.dists.negativeBinomial.NegativeBinomial":[],"base.dists.negativeBinomial.pmf":[],"base.dists.negativeBinomial.quantile":[],"base.dists.negativeBinomial.skewness":[],"base.dists.negativeBinomial.stdev":[],"base.dists.negativeBinomial.variance":[],"base.dists.normal.cdf":[],"base.dists.normal.entropy":[],"base.dists.normal.kurtosis":[],"base.dists.normal.logpdf":[],"base.dists.normal.mean":[],"base.dists.normal.median":[],"base.dists.normal.mgf":[],"base.dists.normal.mode":[],"base.dists.normal.Normal":[],"base.dists.normal.pdf":[],"base.dists.normal.quantile":[],"base.dists.normal.skewness":[],"base.dists.normal.stdev":[],"base.dists.normal.variance":[],"base.dists.pareto1.cdf":[],"base.dists.pareto1.entropy":[],"base.dists.pareto1.kurtosis":[],"base.dists.pareto1.logcdf":[],"base.dists.pareto1.logpdf":[],"base.dists.pareto1.mean":[],"base.dists.pareto1.median":[],"base.dists.pareto1.mode":[],"base.dists.pareto1.Pareto1":[],"base.dists.pareto1.pdf":[],"base.dists.pareto1.quantile":[],"base.dists.pareto1.skewness":[],"base.dists.pareto1.variance":[],"base.dists.poisson.cdf":[],"base.dists.poisson.entropy":[],"base.dists.poisson.kurtosis":[],"base.dists.poisson.logpmf":[],"base.dists.poisson.mean":[],"base.dists.poisson.median":[],"base.dists.poisson.mgf":[],"base.dists.poisson.mode":[],"base.dists.poisson.pmf":[],"base.dists.poisson.Poisson":[],"base.dists.poisson.quantile":[],"base.dists.poisson.skewness":[],"base.dists.poisson.stdev":[],"base.dists.poisson.variance":[],"base.dists.rayleigh.cdf":[],"base.dists.rayleigh.entropy":[],"base.dists.rayleigh.kurtosis":[],"base.dists.rayleigh.logcdf":[],"base.dists.rayleigh.logpdf":[],"base.dists.rayleigh.mean":[],"base.dists.rayleigh.median":[],"base.dists.rayleigh.mgf":[],"base.dists.rayleigh.mode":[],"base.dists.rayleigh.pdf":[],"base.dists.rayleigh.quantile":[],"base.dists.rayleigh.Rayleigh":[],"base.dists.rayleigh.skewness":[],"base.dists.rayleigh.stdev":[],"base.dists.rayleigh.variance":[],"base.dists.t.cdf":[],"base.dists.t.entropy":[],"base.dists.t.kurtosis":[],"base.dists.t.mean":[],"base.dists.t.median":[],"base.dists.t.mode":[],"base.dists.t.pdf":[],"base.dists.t.quantile":[],"base.dists.t.skewness":[],"base.dists.t.stdev":[],"base.dists.t.T":[],"base.dists.t.variance":[],"base.dists.triangular.cdf":[],"base.dists.triangular.entropy":[],"base.dists.triangular.kurtosis":[],"base.dists.triangular.logcdf":[],"base.dists.triangular.logpdf":[],"base.dists.triangular.mean":[],"base.dists.triangular.median":[],"base.dists.triangular.mgf":[],"base.dists.triangular.mode":[],"base.dists.triangular.pdf":[],"base.dists.triangular.quantile":[],"base.dists.triangular.skewness":[],"base.dists.triangular.stdev":[],"base.dists.triangular.Triangular":[],"base.dists.triangular.variance":[],"base.dists.uniform.cdf":[],"base.dists.uniform.entropy":[],"base.dists.uniform.kurtosis":[],"base.dists.uniform.logcdf":[],"base.dists.uniform.logpdf":[],"base.dists.uniform.mean":[],"base.dists.uniform.median":[],"base.dists.uniform.mgf":[],"base.dists.uniform.pdf":[],"base.dists.uniform.quantile":[],"base.dists.uniform.skewness":[],"base.dists.uniform.stdev":[],"base.dists.uniform.Uniform":[],"base.dists.uniform.variance":[],"base.dists.weibull.cdf":[],"base.dists.weibull.entropy":[],"base.dists.weibull.kurtosis":[],"base.dists.weibull.logcdf":[],"base.dists.weibull.logpdf":[],"base.dists.weibull.mean":[],"base.dists.weibull.median":[],"base.dists.weibull.mgf":[],"base.dists.weibull.mode":[],"base.dists.weibull.pdf":[],"base.dists.weibull.quantile":[],"base.dists.weibull.skewness":[],"base.dists.weibull.stdev":[],"base.dists.weibull.variance":[],"base.dists.weibull.Weibull":[],"base.ellipe":["base.ellipk"],"base.ellipk":["base.ellipe"],"base.epsdiff":["base.absdiff","base.reldiff"],"base.erf":["base.erfc","base.erfinv","base.erfcinv"],"base.erfc":["base.erf","base.erfinv","base.erfcinv"],"base.erfcinv":["base.erf","base.erfc","base.erfinv"],"base.erfinv":["base.erf","base.erfc","base.erfcinv"],"base.eta":[],"base.evalpoly":["base.evalrational"],"base.evalrational":["base.evalpoly"],"base.exp":["base.exp10","base.exp2","base.expm1","base.ln"],"base.exp2":["base.exp","base.exp10"],"base.exp10":["base.exp","base.exp2"],"base.expit":["base.exp","base.logit"],"base.expm1":["base.exp","base.expm1rel"],"base.expm1rel":["base.exp","base.expm1"],"base.exponent":["base.exponentf"],"base.exponentf":["base.exponent"],"base.factorial":["base.factorialln"],"base.factorialln":["base.factorial"],"base.fallingFactorial":["base.risingFactorial"],"base.fibonacci":["base.binet","base.fibonacciIndex","base.lucas","base.negafibonacci"],"base.fibonacciIndex":["base.fibonacci"],"base.fibpoly":["base.evalpoly","base.lucaspoly"],"base.flipsign":["base.copysign"],"base.float32ToInt32":["base.float32ToUint32"],"base.float32ToUint32":["base.float32ToInt32"],"base.float64ToFloat32":[],"base.float64ToInt32":["base.float64ToUint32"],"base.float64ToUint32":["base.float64ToInt32"],"base.floor":["base.ceil","base.round"],"base.floor2":["base.ceil2","base.floor","base.floor10","base.round2"],"base.floor10":["base.ceil10","base.floor","base.floor2","base.round10"],"base.floorb":["base.ceilb","base.floor","base.floorn","base.roundb"],"base.floorn":["base.ceiln","base.floor","base.floorb","base.roundn"],"base.floorsd":["base.ceilsd","base.floor","base.roundsd","base.truncsd"],"base.fresnel":["base.fresnelc","base.fresnels"],"base.fresnelc":["base.fresnel","base.fresnels"],"base.fresnels":["base.fresnel","base.fresnelc"],"base.frexp":["base.ldexp"],"base.fromBinaryString":["base.fromBinaryStringf","base.toBinaryString"],"base.fromBinaryStringf":["base.toBinaryStringf","base.fromBinaryString"],"base.fromBinaryStringUint8":["base.fromBinaryStringUint16","base.fromBinaryStringUint32","base.toBinaryStringUint8"],"base.fromBinaryStringUint16":["base.toBinaryStringUint16","base.fromBinaryStringUint32","base.fromBinaryStringUint8"],"base.fromBinaryStringUint32":["base.fromBinaryStringUint16","base.toBinaryStringUint32","base.fromBinaryStringUint8"],"base.fromWordf":["base.fromWords"],"base.fromWords":["base.fromWordf"],"base.gamma":["base.gamma1pm1","base.gammainc","base.gammaincinv","base.gammaln"],"base.gamma1pm1":["base.gamma","base.gammainc","base.gammaincinv","base.gammaln"],"base.gammaDeltaRatio":["base.gamma"],"base.gammainc":["base.gamma","base.gamma1pm1","base.gammaincinv","base.gammaln"],"base.gammaincinv":["base.gamma","base.gamma1pm1","base.gammainc","base.gammaln"],"base.gammaLanczosSum":["base.gamma","base.gammaLanczosSumExpGScaled"],"base.gammaLanczosSumExpGScaled":["base.gamma","base.gammaLanczosSum"],"base.gammaln":["base.gamma","base.gammainc","base.gammaincinv"],"base.gasum":["base.dasum","base.sasum"],"base.gaxpy":["base.daxpy","base.saxpy"],"base.gcd":["base.lcm"],"base.gcopy":["base.dcopy"],"base.getHighWord":["base.getLowWord","base.setHighWord"],"base.getLowWord":["base.getHighWord","base.setHighWord"],"base.hacovercos":["base.hacoversin","base.havercos"],"base.hacoversin":["base.hacovercos","base.haversin"],"base.havercos":["base.haversin","base.vercos"],"base.haversin":["base.havercos","base.versin"],"base.heaviside":["base.ramp"],"base.hermitepoly":["base.evalpoly","base.normhermitepoly"],"base.hypot":[],"base.imul":["base.imuldw","base.uimul"],"base.imuldw":["base.imul","base.uimuldw"],"base.int32ToUint32":["base.uint32ToInt32"],"base.inv":["base.pow"],"base.isEven":["base.isOdd"],"base.isEvenInt32":["base.isEven","base.isOddInt32"],"base.isFinite":["base.isInfinite"],"base.isInfinite":["base.isFinite"],"base.isInteger":[],"base.isnan":[],"base.isNegativeInteger":["base.isInteger","base.isNonNegativeInteger","base.isNonPositiveInteger","base.isPositiveInteger"],"base.isNegativeZero":["base.isPositiveZero"],"base.isNonNegativeInteger":["base.isInteger","base.isNegativeInteger","base.isNonPositiveInteger","base.isPositiveInteger"],"base.isNonPositiveInteger":["base.isInteger","base.isNegativeInteger","base.isNonNegativeInteger","base.isPositiveInteger"],"base.isOdd":["base.isEven"],"base.isOddInt32":["base.isEvenInt32","base.isOdd"],"base.isPositiveInteger":["base.isInteger","base.isNegativeInteger","base.isNonNegativeInteger","base.isNonPositiveInteger"],"base.isPositiveZero":["base.isNegativeZero"],"base.isPow2Uint32":[],"base.isProbability":[],"base.isSafeInteger":[],"base.kernelBetainc":["base.betainc"],"base.kernelBetaincinv":["base.betaincinv"],"base.kernelCos":["base.cos","base.kernelSin","base.kernelTan"],"base.kernelSin":["base.kernelCos","base.kernelTan","base.sin"],"base.kernelTan":["base.kernelCos","base.kernelSin","base.tan"],"base.kroneckerDelta":["base.diracDelta"],"base.lcm":["base.gcd"],"base.ldexp":["base.frexp"],"base.ln":["base.exp","base.log10","base.log1p","base.log2"],"base.log":["base.exp","base.ln","base.log10","base.log1p","base.log2"],"base.log1mexp":["base.exp","base.ln","base.log1p","base.log1pexp"],"base.log1p":["base.ln","base.log"],"base.log1pexp":["base.exp","base.ln","base.log1mexp","base.log1p"],"base.log2":["base.exp2","base.ln","base.log"],"base.log10":["base.exp10","base.ln","base.log"],"base.logaddexp":["base.exp","base.ln"],"base.logit":[],"base.lucas":["base.fibonacci","base.negalucas"],"base.lucaspoly":["base.evalpoly","base.fibpoly"],"base.max":["base.maxabs","base.min"],"base.maxabs":["base.max","base.minabs"],"base.min":["base.max","base.minabs"],"base.minabs":["base.maxabs","base.min"],"base.minmax":["base.max","base.min","base.minmaxabs"],"base.minmaxabs":["base.maxabs","base.minabs","base.minmax"],"base.modf":[],"base.ndarray":["array","ndarray"],"base.ndarrayMemoized":["array","base.ndarray","ndarray","ndarrayMemoized"],"base.negafibonacci":["base.fibonacci","base.negalucas"],"base.negalucas":["base.fibonacci","base.lucas","base.negafibonacci"],"base.nonfibonacci":["base.fibonacci"],"base.normalize":["base.normalizef"],"base.normalizef":["base.normalize"],"base.normhermitepoly":["base.evalpoly","base.hermitepoly"],"base.pdiff":[],"base.polygamma":["base.trigamma","base.digamma","base.gamma"],"base.pow":["base.exp","base.powm1"],"base.powm1":["base.pow"],"base.rad2deg":["base.deg2rad"],"base.ramp":["base.heaviside"],"base.random.arcsine":["base.random.beta"],"base.random.bernoulli":["base.random.binomial"],"base.random.beta":[],"base.random.betaprime":[],"base.random.binomial":[],"base.random.boxMuller":[],"base.random.cauchy":[],"base.random.chi":[],"base.random.chisquare":[],"base.random.cosine":[],"base.random.discreteUniform":[],"base.random.erlang":[],"base.random.exponential":[],"base.random.f":[],"base.random.frechet":[],"base.random.gamma":[],"base.random.geometric":[],"base.random.gumbel":[],"base.random.hypergeometric":[],"base.random.improvedZiggurat":[],"base.random.invgamma":[],"base.random.kumaraswamy":[],"base.random.laplace":[],"base.random.levy":[],"base.random.logistic":[],"base.random.lognormal":[],"base.random.minstd":["base.random.minstdShuffle","base.random.mt19937","base.random.randi"],"base.random.minstdShuffle":["base.random.minstd","base.random.mt19937","base.random.randi"],"base.random.mt19937":["base.random.minstd","base.random.randi"],"base.random.negativeBinomial":[],"base.random.normal":[],"base.random.pareto1":[],"base.random.poisson":[],"base.random.randi":["base.random.minstd","base.random.minstdShuffle","base.random.mt19937"],"base.random.randn":["base.random.improvedZiggurat","base.random.randu"],"base.random.randu":["base.random.discreteUniform","base.random.randn"],"base.random.rayleigh":[],"base.random.t":[],"base.random.triangular":[],"base.random.uniform":["base.random.discreteUniform","base.random.randu"],"base.random.weibull":[],"base.reldiff":["base.absdiff","base.epsdiff"],"base.rempio2":[],"base.risingFactorial":["base.fallingFactorial"],"base.rotl32":["base.rotr32"],"base.rotr32":["base.rotl32"],"base.round":["base.ceil","base.floor","base.roundn","base.trunc"],"base.round2":["base.ceil2","base.floor2","base.round","base.round10"],"base.round10":["base.ceil10","base.floor10","base.round","base.round2"],"base.roundb":["base.ceilb","base.floorb","base.round","base.roundn"],"base.roundn":["base.ceiln","base.floorn","base.round","base.roundb"],"base.roundsd":["base.ceilsd","base.floorsd","base.round","base.truncsd"],"base.rsqrt":["base.sqrt"],"base.sasum":["base.dasum"],"base.saxpy":["base.daxpy"],"base.scopy":["base.dcopy"],"base.setHighWord":["base.getHighWord","base.setLowWord"],"base.setLowWord":["base.getLowWord","base.setHighWord"],"base.sici":[],"base.signbit":["base.signbitf"],"base.signbitf":["base.signbit"],"base.significandf":[],"base.signum":[],"base.sin":["base.cos","base.sinpi","base.tan"],"base.sinc":["base.sin"],"base.sincos":["base.cos","base.sin","base.sincospi"],"base.sincospi":["base.cospi","base.sincos","base.sinpi"],"base.sinh":["base.cosh","base.sin","base.tanh"],"base.sinpi":["base.sin"],"base.spence":[],"base.sqrt":["base.cbrt","base.rsqrt"],"base.sqrt1pm1":["base.sqrt"],"base.sumSeries":[],"base.tan":["base.cos","base.sin"],"base.tanh":["base.cosh","base.sinh","base.tan"],"base.toBinaryString":["base.fromBinaryString","base.toBinaryStringf"],"base.toBinaryStringf":["base.fromBinaryStringf","base.toBinaryString"],"base.toBinaryStringUint8":["base.toBinaryString"],"base.toBinaryStringUint16":["base.toBinaryString"],"base.toBinaryStringUint32":["base.toBinaryString"],"base.toWordf":["base.fromWordf","base.toWords"],"base.toWords":["base.fromWords","base.toWordf"],"base.trigamma":["base.digamma","base.gamma"],"base.trunc":["base.ceil","base.floor","base.round"],"base.trunc2":["base.ceil2","base.floor2","base.round2","base.trunc","base.trunc10"],"base.trunc10":["base.ceil10","base.floor10","base.round10","base.trunc","base.trunc2"],"base.truncb":["base.ceilb","base.floorb","base.roundb","base.trunc","base.truncn"],"base.truncn":["base.ceiln","base.floorn","base.roundn","base.trunc","base.truncb"],"base.truncsd":["base.ceilsd","base.floorsd","base.roundsd","base.trunc"],"base.uimul":["base.imul"],"base.uimuldw":["base.imuldw","base.uimul"],"base.uint32ToInt32":[],"base.vercos":["base.cos","base.versin"],"base.versin":["base.cos","base.sin","base.vercos"],"base.wrap":["base.clamp"],"base.xlog1py":["base.log1p","base.xlogy"],"base.xlogy":["base.ln","base.xlog1py"],"base.zeta":[],"BERNDT_CPS_WAGES_1985":[],"bifurcate":["bifurcateBy","bifurcateOwn","group"],"bifurcateBy":["bifurcate","groupBy"],"bifurcateByAsync":["bifurcateBy","groupByAsync"],"bifurcateIn":["bifurcate","bifurcateBy","bifurcateOwn","groupIn"],"bifurcateOwn":["bifurcate","bifurcateBy","bifurcateIn","groupOwn"],"binomialTest":[],"Buffer":["ArrayBuffer"],"buffer2json":["typedarray2json","reviveBuffer"],"capitalize":["uncapitalize","uppercase"],"capitalizeKeys":["uncapitalizeKeys","uppercaseKeys"],"CATALAN":[],"CBRT_EPS":["EPS","SQRT_EPS"],"chdir":["cwd"],"chi2gof":[],"circarray2iterator":["array2iterator","stridedarray2iterator"],"circularArrayStream":["arrayStream","iteratorStream","stridedArrayStream"],"CircularBuffer":["FIFO","Stack"],"CMUDICT":[],"complex":["Complex128","Complex64"],"Complex64":["complex","Complex128"],"COMPLEX64_NUM_BYTES":["COMPLEX128_NUM_BYTES","FLOAT32_NUM_BYTES"],"Complex64Array":["Complex128Array","complex","Complex64"],"Complex128":["complex","Complex64"],"COMPLEX128_NUM_BYTES":["COMPLEX64_NUM_BYTES","FLOAT64_NUM_BYTES"],"Complex128Array":["Complex64Array","complex","Complex128"],"compose":["composeAsync"],"composeAsync":["compose"],"configdir":["homedir","tmpdir"],"conj":["imag","real","reim"],"constantFunction":["argumentFunction","identity"],"constantStream":["arrayStream","iteratorStream"],"constructorName":["functionName"],"contains":[],"convertArray":["convertArraySame"],"convertArraySame":["convertArray"],"convertPath":[],"copy":["merge"],"copyBuffer":["allocUnsafe","Buffer"],"countBy":["group","groupBy"],"countByAsync":["countBy","groupByAsync","tabulateByAsync"],"curry":["curryRight","uncurry","uncurryRight"],"curryRight":["curry","uncurry","uncurryRight"],"cwd":["chdir"],"DALE_CHALL_NEW":[],"datasets":[],"dayOfQuarter":["dayOfYear"],"dayOfYear":["dayOfQuarter"],"daysInMonth":["daysInYear"],"daysInYear":["daysInMonth"],"debugSinkStream":["debugStream","inspectSinkStream"],"debugStream":["debugSinkStream","inspectStream"],"deepEqual":["isStrictEqual","isSameValue"],"deepGet":["deepPluck","deepSet"],"deepHasOwnProp":["deepHasProp","hasOwnProp","deepGet","deepPluck","deepSet"],"deepHasProp":["deepHasOwnProp","hasOwnProp","deepGet","deepPluck","deepSet"],"deepPluck":["deepGet","deepSet"],"deepSet":["deepGet","deepPluck"],"defineMemoizedProperty":["setMemoizedReadOnly","defineProperty"],"defineProperties":["defineProperty","setReadOnly"],"defineProperty":["defineProperties","setReadOnly"],"dirname":["extname"],"DoublyLinkedList":["LinkedList","Stack"],"doUntil":["doUntilAsync","doUntilEach","doWhile","until","whilst"],"doUntilAsync":["doUntil","doWhileAsync","untilAsync","whileAsync"],"doUntilEach":["doUntilEachRight","doWhileEach","untilEach"],"doUntilEachRight":["doUntilEach","doWhileEachRight","untilEachRight"],"doWhile":["doUntil","doWhileAsync","doWhileEach","until","whilst"],"doWhileAsync":["doUntilAsync","doWhile","untilAsync","whileAsync"],"doWhileEach":["doUntilEach","doWhileEachRight","whileEach"],"doWhileEachRight":["doUntilEachRight","doWhileEach","whileEachRight"],"E":[],"emptyStream":["constantStream"],"endsWith":["startsWith"],"enumerableProperties":["enumerablePropertiesIn","enumerablePropertySymbols","inheritedEnumerableProperties","objectKeys","nonEnumerableProperties","properties"],"enumerablePropertiesIn":["enumerableProperties","enumerablePropertySymbolsIn","inheritedEnumerableProperties","keysIn","nonEnumerablePropertiesIn","propertiesIn"],"enumerablePropertySymbols":["enumerablePropertySymbolsIn","inheritedEnumerablePropertySymbols","objectKeys","nonEnumerablePropertySymbols","propertySymbols"],"enumerablePropertySymbolsIn":["enumerablePropertySymbols","inheritedEnumerablePropertySymbols","keysIn","nonEnumerablePropertySymbolsIn","propertySymbolsIn"],"ENV":["ARGV"],"EPS":["FLOAT32_EPS"],"error2json":["reviveError"],"EULERGAMMA":[],"every":["any","everyBy","forEach","none","some"],"everyBy":["anyBy","everyByRight","forEach","noneBy","someBy"],"everyByAsync":["anyByAsync","everyBy","everyByRightAsync","forEachAsync","noneByAsync","someByAsync"],"everyByRight":["anyBy","every","everyBy","forEachRight","noneByRight","someByRight"],"everyByRightAsync":["anyByRightAsync","everyByAsync","everyByRight","forEachRightAsync","noneByRightAsync","someByRightAsync"],"evil":[],"exists":["readFile","readDir"],"expandContractions":[],"extname":["dirname"],"fastmath.abs":["base.abs"],"fastmath.acosh":["base.acosh"],"fastmath.ampbm":["base.hypot"],"fastmath.asinh":["base.asinh"],"fastmath.atanh":["base.atanh"],"fastmath.hypot":["base.hypot"],"fastmath.log2Uint32":["base.log2"],"fastmath.max":["base.max"],"fastmath.min":["base.min"],"fastmath.powint":["base.pow"],"fastmath.sqrtUint32":["base.sqrt"],"FEMALE_FIRST_NAMES_EN":["MALE_FIRST_NAMES_EN"],"FIFO":["Stack"],"find":[],"flattenArray":["flattenObject"],"flattenObject":["flattenArray"],"flignerTest":["bartlettTest"],"FLOAT16_CBRT_EPS":["FLOAT16_EPS","FLOAT16_SQRT_EPS","FLOAT32_CBRT_EPS","CBRT_EPS"],"FLOAT16_EPS":["FLOAT32_EPS","EPS"],"FLOAT16_EXPONENT_BIAS":["FLOAT32_EXPONENT_BIAS","FLOAT64_EXPONENT_BIAS"],"FLOAT16_MAX":["FLOAT32_MAX","FLOAT64_MAX"],"FLOAT16_MAX_SAFE_INTEGER":["FLOAT16_MIN_SAFE_INTEGER","FLOAT32_MAX_SAFE_INTEGER","FLOAT64_MAX_SAFE_INTEGER"],"FLOAT16_MIN_SAFE_INTEGER":["FLOAT16_MAX_SAFE_INTEGER","FLOAT32_MIN_SAFE_INTEGER","FLOAT64_MIN_SAFE_INTEGER"],"FLOAT16_NINF":["FLOAT16_PINF","FLOAT32_NINF","NINF"],"FLOAT16_NUM_BYTES":["FLOAT32_NUM_BYTES","FLOAT64_NUM_BYTES"],"FLOAT16_PINF":["FLOAT16_NINF","FLOAT32_PINF","PINF"],"FLOAT16_PRECISION":["FLOAT32_PRECISION","FLOAT64_PRECISION"],"FLOAT16_SMALLEST_NORMAL":["FLOAT16_SMALLEST_SUBNORMAL","FLOAT32_SMALLEST_NORMAL","FLOAT64_SMALLEST_NORMAL"],"FLOAT16_SMALLEST_SUBNORMAL":["FLOAT16_SMALLEST_NORMAL","FLOAT32_SMALLEST_SUBNORMAL","FLOAT64_SMALLEST_SUBNORMAL"],"FLOAT16_SQRT_EPS":["FLOAT16_EPS","FLOAT32_SQRT_EPS","SQRT_EPS"],"FLOAT32_CBRT_EPS":["FLOAT32_EPS","FLOAT32_SQRT_EPS","CBRT_EPS"],"FLOAT32_EPS":["EPS"],"FLOAT32_EXPONENT_BIAS":["FLOAT16_EXPONENT_BIAS","FLOAT64_EXPONENT_BIAS"],"FLOAT32_MAX":["FLOAT16_MAX","FLOAT64_MAX"],"FLOAT32_MAX_SAFE_INTEGER":["FLOAT16_MAX_SAFE_INTEGER","FLOAT32_MIN_SAFE_INTEGER","FLOAT64_MAX_SAFE_INTEGER"],"FLOAT32_MIN_SAFE_INTEGER":["FLOAT16_MIN_SAFE_INTEGER","FLOAT32_MAX_SAFE_INTEGER","FLOAT64_MIN_SAFE_INTEGER"],"FLOAT32_NINF":["FLOAT32_PINF","NINF"],"FLOAT32_NUM_BYTES":["FLOAT16_NUM_BYTES","FLOAT64_NUM_BYTES"],"FLOAT32_PINF":["FLOAT32_NINF","PINF"],"FLOAT32_PRECISION":["FLOAT16_PRECISION","FLOAT64_PRECISION"],"FLOAT32_SMALLEST_NORMAL":["FLOAT32_SMALLEST_SUBNORMAL","FLOAT64_SMALLEST_NORMAL"],"FLOAT32_SMALLEST_SUBNORMAL":["FLOAT32_SMALLEST_NORMAL","FLOAT64_SMALLEST_SUBNORMAL"],"FLOAT32_SQRT_EPS":["FLOAT32_EPS","SQRT_EPS"],"Float32Array":["ArrayBuffer","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"FLOAT64_EXPONENT_BIAS":["FLOAT16_EXPONENT_BIAS","FLOAT32_EXPONENT_BIAS"],"FLOAT64_HIGH_WORD_EXPONENT_MASK":["FLOAT64_HIGH_WORD_SIGNIFICAND_MASK"],"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK":["FLOAT64_HIGH_WORD_EXPONENT_MASK"],"FLOAT64_MAX":["FLOAT16_MAX","FLOAT32_MAX"],"FLOAT64_MAX_BASE2_EXPONENT":["FLOAT64_MAX_BASE10_EXPONENT","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE2_EXPONENT"],"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL":["FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MAX_BASE2_EXPONENT","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"],"FLOAT64_MAX_BASE10_EXPONENT":["FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MAX_BASE2_EXPONENT","FLOAT64_MIN_BASE10_EXPONENT"],"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL":["FLOAT64_MAX_BASE10_EXPONENT","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL"],"FLOAT64_MAX_LN":["FLOAT64_MIN_LN"],"FLOAT64_MAX_SAFE_FIBONACCI":["FLOAT64_MAX_SAFE_NTH_FIBONACCI"],"FLOAT64_MAX_SAFE_INTEGER":["FLOAT16_MAX_SAFE_INTEGER","FLOAT32_MAX_SAFE_INTEGER","FLOAT64_MIN_SAFE_INTEGER"],"FLOAT64_MAX_SAFE_LUCAS":["FLOAT64_MAX_SAFE_FIBONACCI","FLOAT64_MAX_SAFE_NTH_LUCAS"],"FLOAT64_MAX_SAFE_NTH_FIBONACCI":["FLOAT64_MAX_SAFE_FIBONACCI"],"FLOAT64_MAX_SAFE_NTH_LUCAS":["FLOAT64_MAX_SAFE_LUCAS","FLOAT64_MAX_SAFE_NTH_FIBONACCI"],"FLOAT64_MIN_BASE2_EXPONENT":["FLOAT64_MAX_BASE2_EXPONENT","FLOAT64_MIN_BASE10_EXPONENT","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"],"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL":["FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE2_EXPONENT"],"FLOAT64_MIN_BASE10_EXPONENT":["FLOAT64_MAX_BASE10_EXPONENT","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE2_EXPONENT"],"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL":["FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE10_EXPONENT","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL"],"FLOAT64_MIN_LN":["FLOAT64_MAX_LN"],"FLOAT64_MIN_SAFE_INTEGER":["FLOAT16_MIN_SAFE_INTEGER","FLOAT32_MIN_SAFE_INTEGER","FLOAT64_MAX_SAFE_INTEGER"],"FLOAT64_NUM_BYTES":["FLOAT16_NUM_BYTES","FLOAT32_NUM_BYTES"],"FLOAT64_PRECISION":["FLOAT16_PRECISION","FLOAT32_PRECISION"],"FLOAT64_SMALLEST_NORMAL":["FLOAT32_SMALLEST_NORMAL","FLOAT64_SMALLEST_SUBNORMAL"],"FLOAT64_SMALLEST_SUBNORMAL":["FLOAT32_SMALLEST_SUBNORMAL","FLOAT64_SMALLEST_NORMAL"],"Float64Array":["ArrayBuffer","Float32Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"forEach":["forEachAsync","forEachRight"],"forEachAsync":["forEach","forEachRightAsync"],"forEachRight":["forEach","forEachRightAsync"],"forEachRightAsync":["forEachAsync","forEachRight"],"forIn":["forEach","forOwn"],"forOwn":["forEach","forIn"],"FOURTH_PI":["PI"],"FOURTH_ROOT_EPS":["EPS"],"FRB_SF_WAGE_RIGIDITY":[],"fromCodePoint":[],"functionName":["constructorName"],"functionSequence":["compose","functionSequenceAsync"],"functionSequenceAsync":["composeAsync","functionSequence"],"GAMMA_LANCZOS_G":[],"getegid":["geteuid","getgid","getuid"],"geteuid":["getegid","getgid","getuid"],"getgid":["getegid","geteuid","getuid"],"getGlobal":[],"getPrototypeOf":["isPrototypeOf"],"getuid":["getegid","geteuid","getgid"],"GLAISHER":[],"group":["bifurcate","countBy","groupBy"],"groupBy":["bifurcateBy","countBy","group"],"groupByAsync":["bifurcateByAsync","countByAsync","groupBy"],"groupIn":["bifurcateIn","groupBy","groupOwn"],"groupOwn":["bifurcateOwn","group","groupBy"],"HALF_LN2":["LN2"],"HALF_PI":["PI"],"HARRISON_BOSTON_HOUSE_PRICES":["HARRISON_BOSTON_HOUSE_PRICES_CORRECTED","PACE_BOSTON_HOUSE_PRICES"],"HARRISON_BOSTON_HOUSE_PRICES_CORRECTED":["HARRISON_BOSTON_HOUSE_PRICES","PACE_BOSTON_HOUSE_PRICES"],"hasArrayBufferSupport":["hasFloat32ArraySupport","hasFloat64ArraySupport","hasInt16ArraySupport","hasInt32ArraySupport","hasInt8ArraySupport","hasNodeBufferSupport","hasSharedArrayBufferSupport","hasUint16ArraySupport","hasUint32ArraySupport","hasUint8ArraySupport","hasUint8ClampedArraySupport"],"hasAsyncAwaitSupport":[],"hasAsyncIteratorSymbolSupport":["hasIteratorSymbolSupport","hasSymbolSupport"],"hasClassSupport":[],"hasDefinePropertiesSupport":["hasDefinePropertySupport"],"hasDefinePropertySupport":["hasDefinePropertiesSupport"],"hasFloat32ArraySupport":[],"hasFloat64ArraySupport":[],"hasFunctionNameSupport":[],"hasGeneratorSupport":[],"hasInt8ArraySupport":[],"hasInt16ArraySupport":[],"hasInt32ArraySupport":[],"hasIteratorSymbolSupport":["hasAsyncIteratorSymbolSupport","hasSymbolSupport"],"hasMapSupport":[],"hasNodeBufferSupport":[],"hasOwnProp":["hasProp"],"hasProp":["hasOwnProp"],"hasProxySupport":[],"hasSetSupport":[],"hasSharedArrayBufferSupport":["hasArrayBufferSupport","hasFloat32ArraySupport","hasFloat64ArraySupport","hasInt16ArraySupport","hasInt32ArraySupport","hasInt8ArraySupport","hasNodeBufferSupport","hasUint16ArraySupport","hasUint32ArraySupport","hasUint8ArraySupport","hasUint8ClampedArraySupport"],"hasSymbolSupport":["hasIteratorSymbolSupport"],"hasToStringTagSupport":[],"hasUint8ArraySupport":[],"hasUint8ClampedArraySupport":[],"hasUint16ArraySupport":[],"hasUint32ArraySupport":[],"hasWeakMapSupport":[],"hasWeakSetSupport":[],"hasWebAssemblySupport":[],"HERNDON_VENUS_SEMIDIAMETERS":[],"homedir":["configdir","tmpdir"],"HOURS_IN_DAY":["HOURS_IN_WEEK"],"HOURS_IN_WEEK":["HOURS_IN_DAY"],"hoursInMonth":["hoursInYear"],"hoursInYear":["hoursInMonth"],"httpServer":[],"identity":["constantFunction"],"ifelse":["ifelseAsync","ifthen"],"ifelseAsync":["ifthenAsync","ifelse"],"ifthen":["ifthenAsync","ifelse"],"ifthenAsync":["ifelseAsync","ifthen"],"imag":["real","reim"],"IMG_ACANTHUS_MOLLIS":["IMG_ALLIUM_OREOPHILUM"],"IMG_AIRPLANE_FROM_ABOVE":[],"IMG_ALLIUM_OREOPHILUM":["IMG_ACANTHUS_MOLLIS"],"IMG_BLACK_CANYON":[],"IMG_DUST_BOWL_HOME":[],"IMG_FRENCH_ALPINE_LANDSCAPE":[],"IMG_LOCOMOTION_HOUSE_CAT":["IMG_LOCOMOTION_NUDE_MALE"],"IMG_LOCOMOTION_NUDE_MALE":["IMG_LOCOMOTION_HOUSE_CAT"],"IMG_MARCH_PASTORAL":[],"IMG_NAGASAKI_BOATS":[],"incrapcorr":["incrmapcorr","incrpcorr","incrpcorr2"],"incrcount":["incrmean","incrsum","incrsummary"],"incrcovariance":["incrmcovariance","incrpcorr","incrvariance"],"incrcovmat":["incrcovariance","incrpcorrmat"],"incrcv":["incrmean","incrmcv","incrstdev","incrvmr"],"increwmean":["increwvariance","incrmean","incrmmean","incrwmean"],"increwstdev":["increwvariance","incrmstdev","incrstdev"],"increwvariance":["increwmean","increwstdev","incrvariance","incrmvariance"],"incrgmean":["incrhmean","incrmean","incrmgmean","incrsummary"],"incrgrubbs":["incrmgrubbs"],"incrhmean":["incrgmean","incrmean","incrmhmean","incrsummary"],"incrkmeans":[],"incrkurtosis":["incrmean","incrskewness","incrstdev","incrsummary","incrvariance"],"incrmaape":["incrmae","incrmape","incrmean","incrmmaape"],"incrmae":["incrmape","incrme","incrmean","incrmmae"],"incrmapcorr":["incrapcorr","incrmpcorr","incrmpcorr2"],"incrmape":["incrmaape","incrmae","incrmean","incrmmape"],"incrmax":["incrmidrange","incrmin","incrmmax","incrrange","incrsummary"],"incrmaxabs":["incrmax","incrminabs","incrmmaxabs"],"incrmcovariance":["incrcovariance","incrmpcorr","incrmvariance"],"incrmcv":["incrcv","incrmmean","incrmstdev","incrmvmr"],"incrmda":["incrmape","incrmmda"],"incrme":["incrmae","incrmean","incrmme"],"incrmean":["incrmidrange","incrmmean","incrstdev","incrsum","incrsummary","incrvariance"],"incrmeanabs":["incrmean","incrmmeanabs","incrsumabs"],"incrmeanabs2":["incrmean","incrmeanabs","incrmmeanabs2","incrsumabs2"],"incrmeanstdev":["incrmean","incrmeanvar","incrmmeanstdev","incrstdev"],"incrmeanvar":["incrmean","incrmeanstdev","incrmmeanvar","incrvariance"],"incrmgmean":["incrgmean","incrmhmean","incrmmean"],"incrmgrubbs":["incrgrubbs"],"incrmhmean":["incrhmean","incrmgmean","incrmmean"],"incrmidrange":["incrmean","incrmax","incrmin","incrrange","incrsummary"],"incrmin":["incrmax","incrmidrange","incrmmin","incrrange","incrsummary"],"incrminabs":["incrmaxabs","incrmin","incrmminabs"],"incrminmax":["incrmax","incrmin","incrmminmax","incrrange"],"incrminmaxabs":["incrmaxabs","incrminabs","incrminmax","incrmminmaxabs"],"incrmmaape":["incrmaape","incrmmape","incrmmpe","incrmmean"],"incrmmae":["incrmae","incrmme","incrmmean"],"incrmmape":["incrmape","incrmmaape","incrmmpe","incrmmean"],"incrmmax":["incrmax","incrmmidrange","incrmmin","incrmrange","incrmsummary"],"incrmmaxabs":["incrmaxabs","incrmmax","incrmminabs"],"incrmmda":["incrmda","incrmmape"],"incrmme":["incrme","incrmmae","incrmmean"],"incrmmean":["incrmean","incrmsum","incrmstdev","incrmsummary","incrmvariance"],"incrmmeanabs":["incrmeanabs","incrmmean","incrmsumabs"],"incrmmeanabs2":["incrmeanabs2","incrmmeanabs","incrmsumabs2"],"incrmmeanstdev":["incrmeanstdev","incrmmean","incrmmeanvar","incrmstdev"],"incrmmeanvar":["incrmeanvar","incrmmean","incrmmeanstdev","incrmvariance"],"incrmmidrange":["incrmmean","incrmmax","incrmmin","incrmrange"],"incrmmin":["incrmin","incrmmax","incrmmidrange","incrmrange","incrmsummary"],"incrmminabs":["incrminabs","incrmmaxabs","incrmmin"],"incrmminmax":["incrmax","incrmin","incrmmax","incrminmax","incrmmin","incrmrange"],"incrmminmaxabs":["incrminmaxabs","incrmmax","incrmmaxabs","incrmmin","incrmminabs","incrmminmax"],"incrmmpe":["incrmmape","incrmme","incrmpe"],"incrmmse":["incrmrmse","incrmrss","incrmse"],"incrmpcorr":["incrmcovariance","incrmpcorrdist","incrpcorr"],"incrmpcorr2":["incrmapcorr","incrmpcorr","incrpcorr2"],"incrmpcorrdist":["incrmpcorr","incrpcorrdist"],"incrmpe":["incrmape","incrme","incrmmpe"],"incrmprod":["incrmsum","incrprod"],"incrmrange":["incrmmax","incrmmean","incrmmin","incrmsummary","incrrange"],"incrmrmse":["incrmmse","incrmrss","incrrmse"],"incrmrss":["incrrss","incrmmse","incrmrmse"],"incrmse":["incrmmse","incrrmse","incrrss"],"incrmstdev":["incrmmean","incrmsummary","incrmvariance","incrstdev"],"incrmsum":["incrmmean","incrmsummary","incrsum"],"incrmsumabs":["incrmmeanabs","incrmsum","incrsum","incrsumabs"],"incrmsumabs2":["incrmmeanabs2","incrmsumabs","incrsumabs","incrsumabs2"],"incrmsummary":["incrmmean","incrmstdev","incrmsum","incrmvariance","incrsummary"],"incrmsumprod":["incrmprod","incrmsum","incrsumprod"],"incrmvariance":["incrmmean","incrmstdev","incrmsummary","incrvariance"],"incrmvmr":["incrmmean","incrmvariance","incrvmr"],"incrpcorr":["incrcovariance","incrmpcorr","incrsummary"],"incrpcorr2":["incrapcorr","incrmpcorr2","incrpcorr"],"incrpcorrdist":["incrcovariance","incrpcorr","incrsummary"],"incrpcorrdistmat":["incrpcorrdist","incrpcorrmat"],"incrpcorrmat":["incrcovmat","incrpcorr","incrpcorrdistmat"],"incrprod":["incrmprod","incrsum","incrsummary"],"incrrange":["incrmax","incrmean","incrmin","incrmrange","incrsummary"],"incrrmse":["incrmrmse","incrmse","incrrss"],"incrrss":["incrmrss","incrmse","incrrmse"],"incrskewness":["incrkurtosis","incrmean","incrstdev","incrsummary","incrvariance"],"incrspace":["linspace","logspace"],"incrstdev":["incrkurtosis","incrmean","incrmstdev","incrskewness","incrsummary","incrvariance"],"incrsum":["incrcount","incrmean","incrmsum","incrprod","incrsummary"],"incrsumabs":["incrmeanabs","incrmsumabs","incrsum"],"incrsumabs2":["incrmeanabs2","incrmsumabs2","incrsumabs"],"incrsummary":["incrcount","incrkurtosis","incrmax","incrmean","incrmidrange","incrmin","incrmsummary","incrrange","incrskewness","incrstdev","incrsum","incrvariance"],"incrsumprod":["incrmsumprod","incrprod","incrsum"],"incrvariance":["incrkurtosis","incrmean","incrmstdev","incrskewness","incrstdev","incrsummary"],"incrvmr":["incrmean","incrmvmr","incrvariance"],"incrwmean":["increwmean","incrmean","incrmmean"],"ind2sub":["array","ndarray","sub2ind"],"indexOf":[],"inherit":[],"inheritedEnumerableProperties":["enumerableProperties","enumerablePropertiesIn","inheritedEnumerablePropertySymbols","inheritedKeys","inheritedNonEnumerableProperties","inheritedProperties"],"inheritedEnumerablePropertySymbols":["enumerableProperties","enumerablePropertySymbols","inheritedKeys","nonEnumerablePropertySymbols","nonEnumerablePropertySymbolsIn","propertySymbols"],"inheritedKeys":["objectKeys","keysIn","inheritedPropertyNames","inheritedPropertySymbols"],"inheritedNonEnumerableProperties":["inheritedEnumerableProperties","inheritedNonEnumerablePropertyNames","inheritedNonEnumerablePropertySymbols","inheritedKeys","nonEnumerableProperties","nonEnumerablePropertiesIn","properties"],"inheritedNonEnumerablePropertyNames":["inheritedNonEnumerableProperties","inheritedNonEnumerablePropertySymbols","objectKeys","nonEnumerablePropertyNames","nonEnumerablePropertyNamesIn","nonEnumerablePropertySymbols","propertyNames"],"inheritedNonEnumerablePropertySymbols":["inheritedNonEnumerableProperties","inheritedNonEnumerablePropertyNames","nonEnumerableProperties","nonEnumerablePropertyNames","nonEnumerablePropertySymbols","nonEnumerablePropertySymbolsIn","propertySymbols"],"inheritedProperties":["properties","propertiesIn","inheritedPropertyNames","inheritedPropertySymbols"],"inheritedPropertyDescriptor":["propertyDescriptor","propertyDescriptorIn","inheritedKeys","inheritedPropertyDescriptors","inheritedPropertyNames","inheritedPropertySymbols"],"inheritedPropertyDescriptors":["propertyDescriptors","propertyDescriptorsIn","inheritedKeys","inheritedPropertyNames","inheritedPropertySymbols"],"inheritedPropertyNames":["inheritedKeys","inheritedPropertyDescriptors","inheritedPropertySymbols","propertyNames","propertyNamesIn"],"inheritedPropertySymbols":["inheritedKeys","inheritedPropertyDescriptors","inheritedPropertyNames","propertySymbols","propertySymbolsIn"],"inheritedWritableProperties":["inheritedWritablePropertyNames","inheritedWritablePropertySymbols","writableProperties","writablePropertiesIn","properties"],"inheritedWritablePropertyNames":["inheritedWritablePropertySymbols","writablePropertyNames","writablePropertyNamesIn","properties"],"inheritedWritablePropertySymbols":["inheritedWritablePropertyNames","writablePropertySymbols","writablePropertySymbolsIn","properties"],"inmap":["forEach","inmapRight"],"inmapAsync":["forEachAsync","inmapRightAsync","inmap"],"inmapRight":["forEachRight","inmap"],"inmapRightAsync":["forEachRightAsync","inmapAsync","inmapRight"],"inspectSinkStream":["debugSinkStream","inspectStream"],"inspectStream":["debugStream"],"instanceOf":["isPrototypeOf","constructorName","inherit","typeOf"],"INT8_MAX":["INT8_MIN"],"INT8_MIN":["INT8_MAX"],"INT8_NUM_BYTES":["INT16_NUM_BYTES","INT32_NUM_BYTES","UINT8_NUM_BYTES"],"Int8Array":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"INT16_MAX":["INT16_MIN"],"INT16_MIN":["INT16_MAX"],"INT16_NUM_BYTES":["INT32_NUM_BYTES","INT8_NUM_BYTES","UINT16_NUM_BYTES"],"Int16Array":["ArrayBuffer","Float32Array","Float64Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"INT32_MAX":["INT32_MIN"],"INT32_MIN":["INT32_MAX"],"INT32_NUM_BYTES":["INT16_NUM_BYTES","INT8_NUM_BYTES","UINT32_NUM_BYTES"],"Int32Array":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int8Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"IS_BIG_ENDIAN":["IS_LITTLE_ENDIAN"],"IS_BROWSER":[],"IS_DARWIN":[],"IS_ELECTRON":["IS_ELECTRON_MAIN","IS_ELECTRON_RENDERER"],"IS_ELECTRON_MAIN":["IS_ELECTRON","IS_ELECTRON_RENDERER"],"IS_ELECTRON_RENDERER":["IS_ELECTRON","IS_ELECTRON_MAIN"],"IS_LITTLE_ENDIAN":["IS_BIG_ENDIAN"],"IS_NODE":[],"IS_WEB_WORKER":[],"IS_WINDOWS":[],"isAbsolutePath":["isRelativePath"],"isAccessorProperty":["hasOwnProp","isAccessorPropertyIn","isDataProperty"],"isAccessorPropertyIn":["hasProp","isAccessorProperty","isDataPropertyIn"],"isAlphagram":["isAnagram"],"isAlphaNumeric":["isDigitString"],"isAnagram":["isAlphagram"],"isArguments":[],"isArray":["isArrayLike"],"isArrayArray":[],"isArrayBuffer":["isSharedArrayBuffer","isTypedArray"],"isArrayLength":["isArray"],"isArrayLike":["isArray","isArrayLikeObject"],"isArrayLikeObject":["isArray","isArrayLike"],"isASCII":["isString"],"isBetween":["isBetweenArray"],"isBetweenArray":["isBetween"],"isBinaryString":["isString"],"isBoolean":[],"isBooleanArray":[],"isBoxedPrimitive":["isPrimitive"],"isBuffer":[],"isCapitalized":["isString"],"isCentrosymmetricMatrix":["isMatrixLike","isSquareMatrix","isSymmetricMatrix"],"isCircular":["isCircularArray","isCircularPlainObject"],"isCircularArray":["isCircular","isCircularPlainObject"],"isCircularPlainObject":["isCircular","isCircularArray"],"isCollection":["isArrayLike"],"isComplex":["isComplex64","isComplex128"],"isComplex64":["isComplex","isComplex128"],"isComplex64Array":["isComplex","isComplex64","isComplex128Array","isComplexTypedArray"],"isComplex128":["isComplex","isComplex64"],"isComplex128Array":["isComplex","isComplex128","isComplex64Array","isComplexTypedArray"],"isComplexLike":["isComplex","isComplex64","isComplex128"],"isComplexTypedArray":["isComplex","isComplex64Array","isComplex128Array"],"isConfigurableProperty":["isConfigurablePropertyIn","isEnumerableProperty","isReadableProperty","isWritableProperty"],"isConfigurablePropertyIn":["isConfigurableProperty","isEnumerablePropertyIn","isReadablePropertyIn","isWritablePropertyIn"],"isDataProperty":["hasOwnProp","isAccessorProperty","isDataPropertyIn"],"isDataPropertyIn":["hasProp","isAccessorPropertyIn","isDataProperty"],"isDateObject":[],"isDigitString":["isHexString","isString"],"isEmailAddress":[],"isEmptyArray":["isArray"],"isEmptyObject":["isObject","isPlainObject"],"isEmptyString":["isString"],"isEnumerableProperty":["isConfigurableProperty","isEnumerablePropertyIn","isNonEnumerableProperty","isReadableProperty","isWritableProperty"],"isEnumerablePropertyIn":["isConfigurablePropertyIn","isEnumerableProperty","isNonEnumerablePropertyIn","isReadablePropertyIn","isWritablePropertyIn"],"isError":[],"isEvalError":["isError"],"isEven":["isOdd"],"isFalsy":["isFalsyArray","isTruthy"],"isFalsyArray":["isFalsy","isTruthyArray"],"isFinite":["isFiniteArray","isInfinite"],"isFiniteArray":["isFinite","isInfinite"],"isFloat32Array":["isFloat64Array"],"isFloat64Array":["isFloat32Array"],"isFunction":[],"isFunctionArray":["isArray"],"isGeneratorObject":["hasGeneratorSupport","isGeneratorObjectLike"],"isGeneratorObjectLike":["hasGeneratorSupport","isGeneratorObject"],"isHexString":["isString"],"isInfinite":["isFinite"],"isInheritedProperty":["hasOwnProp","hasProp"],"isInt8Array":["isInt16Array","isInt32Array"],"isInt16Array":["isInt32Array","isInt8Array"],"isInt32Array":["isInt16Array","isInt8Array"],"isInteger":["isNumber"],"isIntegerArray":["isArray"],"isIterableLike":["isIteratorLike"],"isIteratorLike":["isIterableLike"],"isJSON":[],"isLeapYear":[],"isLowercase":["isString","isUppercase"],"isMatrixLike":["isArray","isArrayLike","isndarrayLike","isTypedArrayLike","isVectorLike"],"isMethod":["hasOwnProp","isFunction","isMethodIn"],"isMethodIn":["hasProp","isFunction","isMethod"],"isNamedTypedTupleLike":["namedtypedtuple"],"isnan":["isNumber"],"isNaNArray":["isnan"],"isNativeFunction":["isFunction"],"isndarrayLike":["isArray","isArrayLike","isMatrixLike","isTypedArrayLike","isVectorLike"],"isNegativeInteger":["isInteger"],"isNegativeIntegerArray":["isArray"],"isNegativeNumber":["isNumber"],"isNegativeNumberArray":["isArray"],"isNegativeZero":["isNumber","isPositiveZero"],"isNodeBuiltin":[],"isNodeDuplexStreamLike":["isNodeStreamLike"],"isNodeReadableStreamLike":["isNodeStreamLike"],"isNodeREPL":[],"isNodeStreamLike":[],"isNodeTransformStreamLike":["isNodeStreamLike"],"isNodeWritableStreamLike":["isNodeStreamLike"],"isNonConfigurableProperty":["isConfigurableProperty","isEnumerableProperty","isNonConfigurablePropertyIn","isNonEnumerableProperty","isReadableProperty","isWritableProperty"],"isNonConfigurablePropertyIn":["isConfigurablePropertyIn","isEnumerablePropertyIn","isNonConfigurableProperty","isNonEnumerablePropertyIn","isReadablePropertyIn","isWritablePropertyIn"],"isNonEnumerableProperty":["isConfigurableProperty","isEnumerableProperty","isNonConfigurableProperty","isNonEnumerablePropertyIn","isReadableProperty","isWritableProperty"],"isNonEnumerablePropertyIn":["isConfigurablePropertyIn","isEnumerablePropertyIn","isNonConfigurablePropertyIn","isNonEnumerableProperty","isReadablePropertyIn","isWritablePropertyIn"],"isNonNegativeInteger":["isInteger"],"isNonNegativeIntegerArray":["isArray"],"isNonNegativeNumber":["isNumber"],"isNonNegativeNumberArray":["isArray"],"isNonPositiveInteger":["isInteger"],"isNonPositiveIntegerArray":["isArray"],"isNonPositiveNumber":["isNumber"],"isNonPositiveNumberArray":["isArray"],"isNonSymmetricMatrix":["isMatrixLike","isSquareMatrix","isSymmetricMatrix"],"isNull":["isUndefined","isUndefinedOrNull"],"isNullArray":["isArray","isNull"],"isNumber":[],"isNumberArray":["isArray","isNumber","isNumericArray"],"isNumericArray":["isArray","isNumberArray","isTypedArray"],"isObject":["isObjectLike","isPlainObject"],"isObjectArray":["isArray","isObject"],"isObjectLike":["isObject","isPlainObject"],"isOdd":["isEven"],"isoWeeksInYear":[],"isPersymmetricMatrix":["isMatrixLike","isSquareMatrix","isSymmetricMatrix"],"isPlainObject":["isObject"],"isPlainObjectArray":["isArray","isPlainObject"],"isPositiveInteger":["isInteger"],"isPositiveIntegerArray":["isArray","isInteger","isPositiveInteger"],"isPositiveNumber":["isNumber"],"isPositiveNumberArray":["isArray","isNumber","isPositiveNumber"],"isPositiveZero":["isNumber","isNegativeZero"],"isPrimitive":["isBoxedPrimitive"],"isPrimitiveArray":["isArray","isPrimitive"],"isPRNGLike":[],"isProbability":["isNumber"],"isProbabilityArray":["isArray","isProbability"],"isPrototypeOf":["getPrototypeOf"],"isRangeError":["isError"],"isReadableProperty":["isReadOnlyProperty","isReadWriteProperty","isReadablePropertyIn","isWritableProperty"],"isReadablePropertyIn":["isReadOnlyPropertyIn","isReadWritePropertyIn","isReadableProperty","isWritablePropertyIn"],"isReadOnlyProperty":["isReadOnlyPropertyIn","isReadWriteProperty","isReadableProperty","isWritableProperty"],"isReadOnlyPropertyIn":["isReadOnlyProperty","isReadWritePropertyIn","isReadablePropertyIn","isWritablePropertyIn"],"isReadWriteProperty":["isReadOnlyProperty","isReadWritePropertyIn","isReadableProperty","isWritableProperty"],"isReadWritePropertyIn":["isReadOnlyPropertyIn","isReadWriteProperty","isReadablePropertyIn","isWritablePropertyIn"],"isReferenceError":["isError"],"isRegExp":[],"isRegExpString":["isRegExp"],"isRelativePath":["isAbsolutePath"],"isSafeInteger":["isInteger","isNumber"],"isSafeIntegerArray":["isArray","isSafeInteger"],"isSameValue":["isSameValueZero","isStrictEqual"],"isSameValueZero":["isSameValue","isStrictEqual"],"isSharedArrayBuffer":["isArrayBuffer","isTypedArray"],"isSkewCentrosymmetricMatrix":["isCentrosymmetricMatrix","isMatrixLike","isSkewSymmetricMatrix"],"isSkewPersymmetricMatrix":["isMatrixLike","isPersymmetricMatrix","isSkewSymmetricMatrix"],"isSkewSymmetricMatrix":["isMatrixLike","isSkewSymmetricMatrix","isSquareMatrix"],"isSquareMatrix":["isMatrixLike","isSymmetricMatrix"],"isStrictEqual":["isSameValue"],"isString":[],"isStringArray":["isArray","isString"],"isSymbol":[],"isSymbolArray":["isArray","isSymbol"],"isSymmetricMatrix":["isMatrixLike","isNonSymmetricMatrix","isSquareMatrix"],"isSyntaxError":["isError"],"isTruthy":["isFalsy"],"isTruthyArray":["isFalsyArray","isTruthy"],"isTypedArray":["isArray","isTypedArrayLike"],"isTypedArrayLength":["isArrayLength","isTypedArray"],"isTypedArrayLike":["isTypedArray"],"isTypeError":["isError"],"isUint8Array":["isTypedArray","isUint16Array","isUint32Array"],"isUint8ClampedArray":["isTypedArray","isUint8Array"],"isUint16Array":["isTypedArray","isUint32Array","isUint8Array"],"isUint32Array":["isTypedArray","isUint16Array","isUint8Array"],"isUNCPath":[],"isUndefined":["isNull","isUndefinedOrNull"],"isUndefinedOrNull":["isNull","isUndefined"],"isUnityProbabilityArray":["isProbability","isProbabilityArray"],"isUppercase":["isLowercase","isString"],"isURI":[],"isURIError":["isError"],"isVectorLike":["isArray","isArrayLike","isMatrixLike","isndarrayLike","isTypedArrayLike"],"isWhitespace":["RE_WHITESPACE"],"isWritableProperty":["isReadableProperty","isReadWriteProperty","isWritablePropertyIn","isWriteOnlyProperty"],"isWritablePropertyIn":["isReadablePropertyIn","isReadWritePropertyIn","isWritableProperty","isWriteOnlyPropertyIn"],"isWriteOnlyProperty":["isReadOnlyProperty","isReadWriteProperty","isWritableProperty","isWriteOnlyPropertyIn"],"isWriteOnlyPropertyIn":["isReadOnlyPropertyIn","isReadWritePropertyIn","isWritablePropertyIn","isWriteOnlyProperty"],"iterAdd":["iterDivide","iterMultiply","iterSubtract"],"iterAdvance":["iterHead","iterSlice"],"iterAny":["iterAnyBy","iterEvery","iterForEach","iterNone","iterSome"],"iterAnyBy":["iterAny","iterEveryBy","iterForEach","iterNoneBy","iterSomeBy"],"iterator2array":["array2iterator","iterator2arrayview"],"iterator2arrayview":["iterator2array","arrayview2iterator","iterator2arrayviewRight"],"iterator2arrayviewRight":["iterator2array","arrayview2iteratorRight","iterator2arrayview"],"iteratorStream":["arrayStream"],"IteratorSymbol":["Symbol"],"iterawgn":["iterawln","iterawun"],"iterawln":["iterawgn","iterawun"],"iterawun":["iterawgn","iterawln"],"iterBartlettHannPulse":["iterBartlettPulse","iterHannPulse","iterPulse","iterTriangleWave"],"iterBartlettPulse":["iterBartlettHannPulse","iterPulse","iterTriangleWave"],"iterConcat":[],"iterConstant":["constantFunction"],"iterCosineWave":["iterPulse","iterSawtoothWave","iterSineWave","iterSquareWave","iterTriangleWave"],"iterCounter":["iterLength"],"itercugmean":["itercuhmean","itercumean"],"itercuhmean":["itercugmean","itercumean"],"itercumax":["itercumidrange","itercumin","itercurange","itermax"],"itercumaxabs":["itercumax","itercuminabs","itermaxabs"],"itercumean":["itercumidrange","itercusum","itermean"],"itercumeanabs":["itercumean","itercumeanabs2","itercusumabs","itermeanabs"],"itercumeanabs2":["itercumean","itercumeanabs","itercusumabs2","itermeanabs2"],"itercumidrange":["itercumean","itercumax","itercumin","itercurange","itermidrange"],"itercumin":["itercumax","itercumidrange","itercurange","itermin"],"itercuminabs":["itercumaxabs","itercumin","iterminabs"],"itercuprod":["itercusum","iterprod"],"itercurange":["itercumax","itercumean","itercumin","iterrange"],"itercusum":["itercumean","itersum","itercuprod"],"itercusumabs":["itercumeanabs","itercusum","itersumabs"],"itercusumabs2":["itercumeanabs2","itercusumabs","itersumabs2"],"iterDedupe":["iterDedupeBy","iterUnique"],"iterDedupeBy":["iterDedupe","iterUnique"],"iterDiracComb":["iterPulse"],"iterDivide":["iterAdd","iterDivide","iterMultiply"],"iterEmpty":["iterConstant"],"iterEvery":["iterAny","iterEveryBy","iterForEach","iterNone","iterSome"],"iterEveryBy":["iterAnyBy","iterEvery","iterForEach","iterNoneBy","iterSomeBy"],"iterFibonacci":["base.fibonacci","iterNonFibonacci"],"iterFill":[],"iterFilter":["iterFilterMap","iterMap","iterReject"],"iterFilterMap":["iterFilter","iterMap"],"iterFirst":["iterHead","iterLast","iterNth"],"iterFlatTopPulse":["iterPulse"],"iterFlow":["iterPipeline"],"iterForEach":["iterMap"],"iterHannPulse":["iterBartlettHannPulse","iterPulse","iterSineWave"],"iterHead":["iterFirst","iterSlice"],"iterIntersection":["iterIntersectionByHash","iterUnion","iterUnique"],"iterIntersectionByHash":["iterIntersection","iterUniqueByHash"],"iterLanczosPulse":["iterPulse","iterPeriodicSinc"],"iterLast":["iterFirst","iterNth"],"iterLength":["iterCounter"],"iterMap":["iterFilter","iterFilterMap","iterForEach","iterReject"],"iterMapN":["iterMap"],"itermax":["itermidrange","itermin","itermmax","iterrange"],"itermaxabs":["itermax","iterminabs","itermmaxabs"],"itermean":["itermidrange","itermmean","iterstdev","itersum","itervariance"],"itermeanabs":["itermean","itermmeanabs","itersumabs"],"itermeanabs2":["itermean","itermeanabs","itermmeanabs2","itersumabs2"],"itermidrange":["itermean","itermax","itermin","iterrange"],"itermin":["itermax","itermidrange","itermmin","iterrange"],"iterminabs":["itermaxabs","itermin","itermminabs"],"itermmax":["itermax","itermmidrange","itermmin","itermrange"],"itermmaxabs":["itermaxabs","itermmax","itermminabs"],"itermmean":["itermean","itermsum"],"itermmeanabs":["itermeanabs","itermmean","itermsumabs"],"itermmeanabs2":["itermeanabs2","itermmeanabs","itermsumabs2"],"itermmidrange":["itermidrange","itermmean","itermmax","itermmin","itermrange"],"itermmin":["itermin","itermmax","itermmidrange","itermrange"],"itermminabs":["iterminabs","itermmaxabs","itermmin"],"iterMod":["iterDivide"],"itermprod":["itermsum","iterprod"],"itermrange":["itermmax","itermmean","itermmin","iterrange"],"itermsum":["itermmean","itersum"],"itermsumabs":["itermmeanabs","itermsum","itersum","itersumabs"],"itermsumabs2":["itermmeanabs2","itermsumabs","itersumabs","itersumabs2"],"iterMultiply":["iterAdd","iterDivide","iterSubtract"],"iterNone":["iterAny","iterEvery","iterForEach","iterNoneBy","iterSome"],"iterNoneBy":["iterAnyBy","iterEveryBy","iterForEach","iterNone","iterSomeBy"],"iterNonFibonacci":["base.nonfibonacci","iterFibonacci"],"iterNth":["iterFirst","iterLast"],"iterPeriodicSinc":["iterSineWave"],"iterPipeline":["iterFlow","iterThunk"],"iterPop":["iterPush","iterShift","iterSlice"],"iterprod":["itermprod","itersum"],"iterPulse":["iterSawtoothWave","iterSineWave","iterSquareWave","iterTriangleWave"],"iterPush":["iterConcat","iterUnshift"],"iterrange":["itermax","itermean","itermin","itermrange"],"iterReject":["iterFilter","iterMap"],"iterReplicate":["iterReplicateBy"],"iterReplicateBy":["iterReplicate"],"iterSawtoothWave":["iterPulse","iterSineWave","iterSquareWave","iterTriangleWave"],"iterShift":["iterPop","iterSlice","iterUnshift"],"iterSineWave":["iterCosineWave","iterPulse","iterSawtoothWave","iterSquareWave","iterTriangleWave"],"iterSlice":["iterFirst","iterHead"],"iterSome":["iterAny","iterEvery","iterForEach","iterNone","iterSomeBy"],"iterSomeBy":["iterAnyBy","iterEveryBy","iterForEach","iterNoneBy","iterSome"],"iterSquareWave":["iterPulse","iterSawtoothWave","iterSineWave","iterTriangleWave"],"iterstdev":["itermean","itervariance"],"iterSubtract":["iterAdd","iterDivide","iterMultiply"],"itersum":["itermean","itermsum","iterprod"],"itersumabs":["itermeanabs","itermsumabs","itersum"],"itersumabs2":["itermeanabs2","itermsumabs2","itersumabs"],"iterThunk":["iterPipeline"],"iterTriangleWave":["iterPulse","iterSawtoothWave","iterSineWave","iterSquareWave"],"iterUnion":["iterIntersection","iterUnique"],"iterUnique":["iterUniqueBy","iterUniqueByHash"],"iterUniqueBy":["iterUnique","iterUniqueByHash"],"iterUniqueByHash":["iterUnique","iterUniqueBy"],"iterUnshift":["iterConcat","iterPush","iterShift"],"itervariance":["itermean","iterstdev"],"joinStream":["splitStream"],"kde2d":[],"keyBy":["forEach"],"keyByRight":["forEachRight","keyBy"],"keysIn":["objectEntriesIn","objectKeys","objectValuesIn"],"kruskalTest":[],"kstest":[],"lda":[],"LinkedList":["DoublyLinkedList","Stack"],"linspace":["incrspace","logspace"],"LIU_NEGATIVE_OPINION_WORDS_EN":["LIU_POSITIVE_OPINION_WORDS_EN"],"LIU_POSITIVE_OPINION_WORDS_EN":["LIU_NEGATIVE_OPINION_WORDS_EN"],"LN_HALF":[],"LN_PI":["PI"],"LN_SQRT_TWO_PI":["PI"],"LN_TWO_PI":["TWO_PI"],"LN2":["LN10"],"LN10":["LN2"],"LOG2E":["E","LOG10E"],"LOG10E":["E","LOG2E"],"logspace":["incrspace","linspace"],"lowercase":["uncapitalize","uppercase"],"lowercaseKeys":["uncapitalizeKeys","uppercaseKeys"],"lowess":[],"lpad":["pad","rpad"],"ltrim":["trim","rtrim"],"MALE_FIRST_NAMES_EN":["FEMALE_FIRST_NAMES_EN"],"mapFun":["mapFunAsync"],"mapFunAsync":["mapFun"],"mapKeys":["mapValues"],"mapKeysAsync":["mapKeys","mapValuesAsync"],"mapValues":["mapKeys","omitBy","pickBy"],"mapValuesAsync":["mapKeysAsync","mapValues"],"MAX_ARRAY_LENGTH":["MAX_TYPED_ARRAY_LENGTH"],"MAX_TYPED_ARRAY_LENGTH":["MAX_ARRAY_LENGTH"],"memoize":[],"merge":["copy"],"MILLISECONDS_IN_DAY":[],"MILLISECONDS_IN_HOUR":[],"MILLISECONDS_IN_MINUTE":[],"MILLISECONDS_IN_SECOND":[],"MILLISECONDS_IN_WEEK":[],"MINARD_NAPOLEONS_MARCH":[],"MINUTES_IN_DAY":[],"MINUTES_IN_HOUR":[],"MINUTES_IN_WEEK":[],"minutesInMonth":["minutesInYear"],"minutesInYear":["minutesInMonth"],"MOBY_DICK":[],"MONTH_NAMES_EN":[],"MONTHS_IN_YEAR":[],"moveProperty":[],"namedtypedtuple":["typedarray"],"nativeClass":["constructorName","typeOf"],"ndarray":["array"],"ndarrayCastingModes":["array","ndarray"],"ndarrayDataTypes":["arrayDataTypes","array","ndarray","typedarrayDataTypes"],"ndarrayIndexModes":["array","ndarray"],"ndarrayMemoized":["array","ndarray"],"ndarrayMinDataType":["ndarrayDataTypes","ndarrayPromotionRules","ndarraySafeCasts"],"ndarrayNextDataType":["ndarrayDataTypes","ndarrayPromotionRules","ndarraySafeCasts"],"ndarrayOrders":["array","ndarray"],"ndarrayPromotionRules":["ndarrayCastingModes","ndarrayDataTypes","ndarraySafeCasts"],"ndarraySafeCasts":["ndarrayCastingModes","ndarrayDataTypes","ndarraySameKindCasts"],"ndarraySameKindCasts":["ndarrayCastingModes","ndarrayDataTypes","ndarraySafeCasts"],"NIGHTINGALES_ROSE":[],"NINF":["FLOAT16_NINF","FLOAT32_NINF","PINF"],"NODE_VERSION":[],"none":["any","every","forEach","noneBy","some"],"noneBy":["anyBy","everyBy","forEach","none","noneByRight","someBy"],"noneByAsync":["anyByAsync","everyByAsync","forEachAsync","noneBy","noneByRightAsync","someByAsync"],"noneByRight":["anyByRight","everyByRight","forEachRight","none","noneBy","someByRight"],"noneByRightAsync":["anyByRightAsync","everyByRightAsync","forEachRightAsync","noneByAsync","noneByRight","someByRightAsync"],"nonEnumerableProperties":["enumerableProperties","inheritedNonEnumerableProperties","nonEnumerablePropertiesIn","properties"],"nonEnumerablePropertiesIn":["enumerablePropertiesIn","inheritedNonEnumerableProperties","nonEnumerableProperties","propertiesIn"],"nonEnumerablePropertyNames":["objectKeys","inheritedNonEnumerablePropertyNames","nonEnumerablePropertyNamesIn","nonEnumerablePropertySymbols","propertyNames"],"nonEnumerablePropertyNamesIn":["keysIn","inheritedNonEnumerablePropertyNames","nonEnumerablePropertyNames","propertyNamesIn"],"nonEnumerablePropertySymbols":["enumerablePropertySymbols","inheritedNonEnumerablePropertySymbols","nonEnumerablePropertyNames","nonEnumerablePropertySymbolsIn","propertySymbols"],"nonEnumerablePropertySymbolsIn":["enumerablePropertySymbolsIn","inheritedNonEnumerablePropertySymbols","nonEnumerablePropertyNamesIn","nonEnumerablePropertySymbols","propertySymbolsIn"],"noop":[],"now":[],"NUM_CPUS":[],"Number":[],"objectEntries":["objectEntriesIn","objectFromEntries","objectKeys","objectValues"],"objectEntriesIn":["objectEntries","objectFromEntries","keysIn","objectValuesIn"],"objectFromEntries":["objectEntries"],"objectInverse":["objectInverseBy"],"objectInverseBy":["objectInverse"],"objectKeys":["objectEntries","keysIn","objectValues"],"objectValues":["objectEntries","objectKeys"],"objectValuesIn":["objectEntriesIn","keysIn","objectValues"],"omit":["omitBy"],"omitBy":["omit"],"onlineBinaryClassification":["onlineSGDRegression"],"onlineSGDRegression":["onlineBinaryClassification"],"openURL":[],"PACE_BOSTON_HOUSE_PRICES":["HARRISON_BOSTON_HOUSE_PRICES","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED"],"pad":["lpad","rpad"],"papply":["papplyRight"],"papplyRight":["papply"],"parallel":[],"parseJSON":[],"PATH_DELIMITER":["PATH_DELIMITER_POSIX","PATH_DELIMITER_WIN32"],"PATH_DELIMITER_POSIX":["PATH_DELIMITER","PATH_DELIMITER_WIN32"],"PATH_DELIMITER_WIN32":["PATH_DELIMITER","PATH_DELIMITER_POSIX"],"PATH_SEP":["PATH_SEP_POSIX","PATH_SEP_WIN32"],"PATH_SEP_POSIX":["PATH_SEP","PATH_SEP_WIN32"],"PATH_SEP_WIN32":["PATH_SEP","PATH_SEP_POSIX"],"pcorrtest":[],"percentEncode":[],"PHI":[],"PI":["TWO_PI"],"PI_SQUARED":["PI"],"pick":["pickBy"],"pickBy":["pick"],"PINF":["NINF"],"pkg2alias":["alias2pkg","aliases","pkg2related"],"pkg2related":["alias2related","aliases","pkg2alias"],"PLATFORM":["ARCH"],"plot":["Plot"],"Plot":["plot"],"pluck":["deepPluck","pick"],"pop":["push","shift","unshift"],"prepend":["append","unshift"],"properties":["defineProperties","inheritedProperties","propertiesIn","propertyNames","propertySymbols"],"propertiesIn":["defineProperties","inheritedProperties","properties","propertyNamesIn","propertySymbolsIn"],"propertyDescriptor":["hasOwnProp","defineProperty","propertyDescriptorIn","propertyDescriptors"],"propertyDescriptorIn":["hasProp","defineProperty","propertyDescriptor","propertyDescriptorsIn"],"propertyDescriptors":["defineProperty","defineProperties","propertyDescriptor","propertyDescriptorsIn","propertyNames","propertySymbols"],"propertyDescriptorsIn":["defineProperties","propertyDescriptorIn","propertyDescriptors","propertyNamesIn","propertySymbolsIn"],"propertyNames":["objectKeys","nonEnumerablePropertyNames","propertyNamesIn","propertySymbols"],"propertyNamesIn":["objectKeys","nonEnumerablePropertyNamesIn","propertyNames","propertySymbolsIn"],"propertySymbols":["propertyNames","propertySymbolsIn"],"propertySymbolsIn":["propertyNamesIn","propertySymbols"],"Proxy":[],"push":["pop","shift","unshift"],"quarterOfYear":["dayOfYear"],"random.iterators.arcsine":["base.random.arcsine"],"random.iterators.bernoulli":["base.random.bernoulli"],"random.iterators.beta":["base.random.beta"],"random.iterators.betaprime":["base.random.betaprime"],"random.iterators.binomial":["base.random.binomial"],"random.iterators.boxMuller":["base.random.boxMuller"],"random.iterators.cauchy":["base.random.cauchy"],"random.iterators.chi":["base.random.chi"],"random.iterators.chisquare":["base.random.chisquare"],"random.iterators.cosine":["base.random.cosine"],"random.iterators.discreteUniform":["base.random.discreteUniform"],"random.iterators.erlang":["base.random.erlang"],"random.iterators.exponential":["base.random.exponential"],"random.iterators.f":["base.random.f"],"random.iterators.frechet":["base.random.frechet"],"random.iterators.gamma":["base.random.gamma"],"random.iterators.geometric":["base.random.geometric"],"random.iterators.gumbel":["base.random.gumbel"],"random.iterators.hypergeometric":["base.random.hypergeometric"],"random.iterators.improvedZiggurat":["base.random.improvedZiggurat"],"random.iterators.invgamma":["base.random.invgamma"],"random.iterators.kumaraswamy":["base.random.kumaraswamy"],"random.iterators.laplace":["base.random.laplace"],"random.iterators.levy":["base.random.levy"],"random.iterators.logistic":["base.random.logistic"],"random.iterators.lognormal":["base.random.lognormal"],"random.iterators.minstd":["base.random.minstd","random.iterators.minstdShuffle","random.iterators.mt19937","random.iterators.randi","random.iterators.randu"],"random.iterators.minstdShuffle":["base.random.minstdShuffle","random.iterators.minstd","random.iterators.mt19937","random.iterators.randi","random.iterators.randu"],"random.iterators.mt19937":["base.random.mt19937","random.iterators.minstd","random.iterators.minstdShuffle","random.iterators.randi","random.iterators.randu"],"random.iterators.negativeBinomial":["base.random.negativeBinomial"],"random.iterators.normal":["base.random.normal"],"random.iterators.pareto1":["base.random.pareto1"],"random.iterators.poisson":["base.random.poisson"],"random.iterators.randi":["base.random.randi","random.iterators.randu"],"random.iterators.randn":["base.random.randn"],"random.iterators.randu":["base.random.randu","random.iterators.randi"],"random.iterators.rayleigh":["base.random.rayleigh"],"random.iterators.t":["base.random.t"],"random.iterators.triangular":["base.random.triangular"],"random.iterators.uniform":["base.random.uniform"],"random.iterators.weibull":["base.random.weibull"],"random.streams.arcsine":["base.random.arcsine","random.iterators.arcsine"],"random.streams.bernoulli":["base.random.bernoulli","random.iterators.bernoulli"],"random.streams.beta":["base.random.beta","random.iterators.beta"],"random.streams.betaprime":["base.random.betaprime","random.iterators.betaprime"],"random.streams.binomial":["base.random.binomial","random.iterators.binomial"],"random.streams.boxMuller":["base.random.boxMuller","random.iterators.boxMuller","random.streams.improvedZiggurat","random.streams.randn"],"random.streams.cauchy":["base.random.cauchy","random.iterators.cauchy"],"random.streams.chi":["base.random.chi","random.iterators.chi"],"random.streams.chisquare":["base.random.chisquare","random.iterators.chisquare"],"random.streams.cosine":["base.random.cosine","random.iterators.cosine"],"random.streams.discreteUniform":["base.random.discreteUniform","random.iterators.discreteUniform"],"random.streams.erlang":["base.random.erlang","random.iterators.erlang"],"random.streams.exponential":["base.random.exponential","random.iterators.exponential"],"random.streams.f":["base.random.f","random.iterators.f"],"random.streams.gamma":["base.random.gamma","random.iterators.gamma"],"random.streams.geometric":["base.random.geometric","random.iterators.geometric"],"random.streams.gumbel":["base.random.gumbel","random.iterators.gumbel"],"random.streams.improvedZiggurat":["base.random.improvedZiggurat","random.iterators.improvedZiggurat","random.streams.boxMuller","random.streams.randn"],"random.streams.invgamma":["base.random.invgamma","random.iterators.invgamma"],"random.streams.kumaraswamy":["base.random.kumaraswamy","random.iterators.kumaraswamy"],"random.streams.laplace":["base.random.laplace","random.iterators.laplace"],"random.streams.levy":["base.random.levy","random.iterators.levy"],"random.streams.logistic":["base.random.logistic","random.iterators.logistic"],"random.streams.lognormal":["base.random.lognormal","random.iterators.lognormal"],"random.streams.minstd":["base.random.minstd","random.iterators.minstd","random.streams.minstdShuffle","random.streams.mt19937","random.streams.randi","random.streams.randu"],"random.streams.minstdShuffle":["base.random.minstdShuffle","random.iterators.minstdShuffle","random.streams.minstd","random.streams.mt19937","random.streams.randi","random.streams.randu"],"random.streams.mt19937":["base.random.mt19937","random.iterators.mt19937","random.streams.minstd","random.streams.minstdShuffle","random.streams.randi","random.streams.randu"],"random.streams.negativeBinomial":["base.random.negativeBinomial","random.iterators.negativeBinomial"],"random.streams.normal":["base.random.normal","random.iterators.normal"],"random.streams.pareto1":["base.random.pareto1","random.iterators.pareto1"],"random.streams.poisson":["base.random.poisson","random.iterators.poisson"],"random.streams.randi":["base.random.randi","random.iterators.randi","random.streams.randu"],"random.streams.randn":["base.random.randn","random.iterators.randn","random.streams.boxMuller","random.streams.improvedZiggurat"],"random.streams.randu":["base.random.randu","random.iterators.randu","random.streams.randi"],"random.streams.rayleigh":["base.random.rayleigh","random.iterators.rayleigh"],"random.streams.t":["base.random.t","random.iterators.t"],"random.streams.uniform":["base.random.uniform","random.iterators.uniform"],"random.streams.weibull":["base.random.weibull","random.iterators.weibull"],"ranks":[],"RE_BASENAME":["RE_BASENAME_POSIX","RE_BASENAME_WINDOWS"],"RE_BASENAME_POSIX":["RE_BASENAME","RE_BASENAME_WINDOWS"],"RE_BASENAME_WINDOWS":["RE_BASENAME","RE_BASENAME_POSIX"],"RE_COLOR_HEXADECIMAL":[],"RE_DECIMAL_NUMBER":[],"RE_DIRNAME":["RE_DIRNAME_POSIX","RE_DIRNAME_WINDOWS","dirname"],"RE_DIRNAME_POSIX":["RE_DIRNAME","RE_DIRNAME_WINDOWS","dirname"],"RE_DIRNAME_WINDOWS":["RE_DIRNAME","RE_DIRNAME_POSIX","dirname"],"RE_EOL":[],"RE_EXTENDED_LENGTH_PATH":[],"RE_EXTNAME":["RE_EXTNAME_POSIX","RE_EXTNAME_WINDOWS","extname"],"RE_EXTNAME_POSIX":["RE_EXTNAME","RE_EXTNAME_WINDOWS","extname"],"RE_EXTNAME_WINDOWS":["RE_EXTNAME","RE_EXTNAME_POSIX","extname"],"RE_FILENAME":["RE_FILENAME_POSIX","RE_FILENAME_WINDOWS"],"RE_FILENAME_POSIX":["RE_FILENAME","RE_FILENAME_WINDOWS"],"RE_FILENAME_WINDOWS":["RE_FILENAME","RE_FILENAME_POSIX"],"RE_FUNCTION_NAME":["functionName"],"RE_NATIVE_FUNCTION":["RE_FUNCTION_NAME","functionName"],"RE_REGEXP":["reFromString"],"RE_UNC_PATH":["isUNCPath"],"RE_UTF16_SURROGATE_PAIR":["RE_UTF16_UNPAIRED_SURROGATE"],"RE_UTF16_UNPAIRED_SURROGATE":["RE_UTF16_SURROGATE_PAIR"],"RE_WHITESPACE":["isWhitespace"],"readDir":["exists","readFile"],"readFile":["exists","readDir","readJSON","writeFile"],"readFileList":[],"readJSON":["readFile"],"readWASM":["readFile"],"real":["imag","reim"],"realmax":["realmin","typemax"],"realmin":["realmax","typemin"],"reduce":["forEach","reduceAsync","reduceRight"],"reduceAsync":["forEachAsync","reduce","reduceRightAsync"],"reduceRight":["forEachRight","reduce","reduceRightAsync"],"reduceRightAsync":["forEachRightAsync","reduceAsync","reduceRight"],"reFromString":[],"reim":["imag","real"],"removeFirst":["removeLast"],"removeLast":["removeFirst"],"removePunctuation":[],"removeUTF8BOM":[],"removeWords":[],"rename":["exists","readFile","writeFile","unlink"],"reorderArguments":["reverseArguments"],"repeat":["pad"],"replace":[],"rescape":[],"resolveParentPath":[],"reverseArguments":["reorderArguments"],"reverseString":[],"reviveBasePRNG":[],"reviveBuffer":["buffer2json"],"reviveComplex":["Complex128","Complex64","reviveComplex128","reviveComplex64"],"reviveComplex64":["Complex64","reviveComplex128","reviveComplex"],"reviveComplex128":["Complex128","reviveComplex64","reviveComplex"],"reviveError":["error2json"],"reviveTypedArray":["typedarray2json"],"rpad":["lpad","pad"],"rtrim":["ltrim","trim"],"safeintmax":["safeintmin","realmax","typemax"],"safeintmin":["safeintmax","realmin","typemin"],"sample":[],"SAVOY_STOPWORDS_FIN":[],"SAVOY_STOPWORDS_FR":[],"SAVOY_STOPWORDS_GER":[],"SAVOY_STOPWORDS_IT":[],"SAVOY_STOPWORDS_POR":[],"SAVOY_STOPWORDS_SP":[],"SAVOY_STOPWORDS_SWE":[],"SECONDS_IN_DAY":[],"SECONDS_IN_HOUR":[],"SECONDS_IN_MINUTE":[],"SECONDS_IN_WEEK":[],"secondsInMonth":["secondsInYear"],"secondsInYear":["secondsInMonth"],"setConfigurableReadOnly":["setConfigurableReadOnlyAccessor","setConfigurableReadWriteAccessor","defineProperty","setReadOnly"],"setConfigurableReadOnlyAccessor":["setConfigurableReadOnly","setConfigurableReadWriteAccessor","setConfigurableWriteOnlyAccessor","defineProperty","setReadOnlyAccessor"],"setConfigurableReadWriteAccessor":["setConfigurableReadOnly","setConfigurableReadOnlyAccessor","setConfigurableWriteOnlyAccessor","defineProperty","setReadWriteAccessor"],"setConfigurableWriteOnlyAccessor":["setConfigurableReadOnly","setConfigurableReadOnlyAccessor","setConfigurableReadWriteAccessor","defineProperty","setWriteOnlyAccessor"],"setMemoizedReadOnly":["defineMemoizedProperty","setReadOnly"],"setNonEnumerableProperty":["setNonEnumerableReadOnlyAccessor","setNonEnumerableReadOnly","setNonEnumerableReadWriteAccessor","setNonEnumerableWriteOnlyAccessor","setReadOnly"],"setNonEnumerableReadOnly":["setNonEnumerableProperty","setNonEnumerableReadOnlyAccessor","setNonEnumerableReadWriteAccessor","setNonEnumerableWriteOnlyAccessor","setReadOnly"],"setNonEnumerableReadOnlyAccessor":["setNonEnumerableProperty","setNonEnumerableReadOnly","setNonEnumerableReadWriteAccessor","setNonEnumerableWriteOnlyAccessor","setReadOnlyAccessor"],"setNonEnumerableReadWriteAccessor":["setNonEnumerableProperty","setNonEnumerableReadOnlyAccessor","setNonEnumerableReadOnly","setNonEnumerableWriteOnlyAccessor","setReadWriteAccessor"],"setNonEnumerableWriteOnlyAccessor":["setNonEnumerableProperty","setNonEnumerableReadOnlyAccessor","setNonEnumerableReadOnly","setNonEnumerableReadWriteAccessor","setWriteOnlyAccessor"],"setReadOnly":["setReadOnlyAccessor","setReadWriteAccessor","setWriteOnlyAccessor"],"setReadOnlyAccessor":["setReadOnly","setReadWriteAccessor","setWriteOnlyAccessor"],"setReadWriteAccessor":["setReadOnly","setReadOnlyAccessor","setWriteOnlyAccessor"],"setWriteOnlyAccessor":["setReadOnly","setReadOnlyAccessor","setReadWriteAccessor"],"SharedArrayBuffer":["Buffer","ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"shift":["pop","push","unshift"],"shuffle":["sample"],"sizeOf":["realmax","typemax"],"some":["any","every","forEach","none","someBy"],"someBy":["anyBy","everyBy","forEach","noneBy","someByAsync","someByRight"],"someByAsync":["anyByAsync","everyByAsync","forEachAsync","noneByAsync","someBy","someByRightAsync"],"someByRight":["anyByRight","everyByRight","forEachRight","noneByRight","someBy","someByRightAsync"],"someByRightAsync":["anyByRightAsync","everyByRightAsync","forEachRightAsync","noneByRightAsync","someByAsync","someByRight"],"SOTU":[],"SPACHE_REVISED":[],"SPAM_ASSASSIN":[],"SparklineBase":["plot","Plot","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeTristateChartSparkline","UnicodeWinLossChartSparkline"],"sparsearray2iterator":["iterator2array","array2iterator","sparsearray2iteratorRight"],"sparsearray2iteratorRight":["iterator2array","array2iteratorRight","sparsearray2iterator"],"splitStream":["joinStream"],"SQRT_EPS":["EPS"],"SQRT_HALF":["LN_HALF"],"SQRT_HALF_PI":["PI"],"SQRT_PHI":["PHI"],"SQRT_PI":["PI"],"SQRT_THREE":[],"SQRT_TWO":["LN2"],"SQRT_TWO_PI":["TWO_PI"],"Stack":["FIFO"],"startcase":["lowercase","uppercase"],"startsWith":["endsWith"],"STOPWORDS_EN":[],"stridedarray2iterator":["iterator2array","array2iterator"],"stridedArrayStream":["arrayStream"],"string2buffer":["Buffer","array2buffer","arraybuffer2buffer","copyBuffer"],"sub2ind":["array","ndarray","ind2sub"],"SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK":["SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK"],"SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK":["SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK"],"Symbol":[],"tabulate":["countBy","groupBy","tabulateBy"],"tabulateBy":["countBy","groupBy","tabulate"],"tabulateByAsync":["countByAsync","groupByAsync","tabulateBy"],"tic":["toc"],"timeit":[],"tmpdir":["configdir","homedir"],"toc":["tic"],"tokenize":[],"transformStream":[],"trim":["ltrim","pad","rtrim"],"trycatch":["trycatchAsync","trythen"],"trycatchAsync":["trycatch","trythenAsync"],"tryFunction":[],"tryRequire":[],"trythen":["trycatch","trythenAsync"],"trythenAsync":["trycatchAsync","trythen"],"ttest":["ttest2"],"ttest2":["ttest"],"TWO_PI":["PI"],"typedarray":["Float64Array","Float32Array","Int32Array","Uint32Array","Int16Array","Uint16Array","Int8Array","Uint8Array","Uint8ClampedArray"],"typedarray2json":["reviveTypedArray"],"typedarrayComplexCtors":["arrayCtors","typedarrayCtors"],"typedarrayComplexDataTypes":["arrayDataTypes","typedarrayDataTypes","ndarrayDataTypes"],"typedarrayCtors":["arrayCtors"],"typedarrayDataTypes":["arrayDataTypes","ndarrayDataTypes"],"typedarraypool":["typedarray"],"typemax":["realmax","typemin"],"typemin":["realmin","typemax"],"typeOf":["constructorName","nativeClass"],"UINT8_MAX":["INT8_MAX"],"UINT8_NUM_BYTES":["INT8_NUM_BYTES","UINT16_NUM_BYTES","UINT32_NUM_BYTES"],"Uint8Array":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8ClampedArray"],"Uint8ClampedArray":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint32Array","Uint8Array"],"UINT16_MAX":["INT16_MAX"],"UINT16_NUM_BYTES":["INT16_NUM_BYTES","UINT32_NUM_BYTES","UINT8_NUM_BYTES"],"Uint16Array":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","Uint32Array","Uint8Array","Uint8ClampedArray"],"UINT32_MAX":["INT32_MAX"],"UINT32_NUM_BYTES":["INT32_NUM_BYTES","UINT16_NUM_BYTES","UINT8_NUM_BYTES"],"Uint32Array":["ArrayBuffer","Float32Array","Float64Array","Int16Array","Int32Array","Int8Array","Uint16Array","Uint8Array","Uint8ClampedArray"],"umask":[],"uncapitalize":["capitalize","lowercase"],"uncapitalizeKeys":["capitalizeKeys","lowercaseKeys"],"uncurry":["curry","uncurryRight"],"uncurryRight":["curry","curryRight","uncurry"],"UNICODE_MAX":["UNICODE_MAX_BMP"],"UNICODE_MAX_BMP":["UNICODE_MAX"],"UnicodeColumnChartSparkline":["plot","Plot","UnicodeSparkline","UnicodeLineChartSparkline","UnicodeTristateChartSparkline","UnicodeUpDownChartSparkline","UnicodeWinLossChartSparkline"],"UnicodeLineChartSparkline":["plot","Plot","UnicodeSparkline","UnicodeColumnChartSparkline","UnicodeTristateChartSparkline","UnicodeUpDownChartSparkline","UnicodeWinLossChartSparkline"],"UnicodeSparkline":["plot","Plot","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeTristateChartSparkline","UnicodeUpDownChartSparkline","UnicodeWinLossChartSparkline"],"UnicodeTristateChartSparkline":["plot","Plot","UnicodeSparkline","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeUpDownChartSparkline","UnicodeWinLossChartSparkline"],"UnicodeUpDownChartSparkline":["plot","Plot","UnicodeSparkline","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeTristateChartSparkline","UnicodeWinLossChartSparkline"],"UnicodeWinLossChartSparkline":["plot","Plot","UnicodeSparkline","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeTristateChartSparkline","UnicodeUpDownChartSparkline"],"unlink":["exists"],"unshift":["pop","push","shift"],"until":["doUntil","doWhile","untilAsync","untilEach","whilst"],"untilAsync":["doUntilAsync","doWhileAsync","until","whileAsync"],"untilEach":["untilEachRight","whileEach"],"untilEachRight":["untilEach","whileEachRight"],"unzip":["zip"],"uppercase":["capitalize","lowercase"],"uppercaseKeys":["capitalizeKeys","lowercaseKeys"],"US_STATES_ABBR":["US_STATES_CAPITALS","US_STATES_NAMES"],"US_STATES_CAPITALS":["US_STATES_ABBR","US_STATES_CAPITALS_NAMES","US_STATES_NAMES","US_STATES_NAMES_CAPITALS"],"US_STATES_CAPITALS_NAMES":["US_STATES_CAPITALS","US_STATES_NAMES","US_STATES_NAMES_CAPITALS"],"US_STATES_NAMES":["US_STATES_ABBR","US_STATES_CAPITALS","US_STATES_CAPITALS_NAMES","US_STATES_NAMES_CAPITALS"],"US_STATES_NAMES_CAPITALS":["US_STATES_CAPITALS","US_STATES_NAMES","US_STATES_NAMES_CAPITALS"],"utf16ToUTF8Array":[],"vartest":["bartlettTest"],"waterfall":[],"whileAsync":["doUntilAsync","doWhileAsync","untilAsync","whilst"],"whileEach":["untilEach","whileEachRight"],"whileEachRight":["whileEach","untilEachRight"],"whilst":["doUntil","doWhile","until","whileAsync","whileEach"],"writableProperties":["inheritedWritableProperties","writablePropertiesIn","properties"],"writablePropertiesIn":["inheritedWritableProperties","writableProperties","propertiesIn"],"writablePropertyNames":["inheritedWritablePropertyNames","writableProperties","writablePropertyNamesIn","writablePropertySymbols","propertyNames"],"writablePropertyNamesIn":["inheritedWritablePropertyNames","writablePropertiesIn","writablePropertyNames","writablePropertySymbolsIn","propertyNamesIn"],"writablePropertySymbols":["inheritedWritablePropertySymbols","writableProperties","writablePropertyNames","writablePropertySymbolsIn","propertySymbols"],"writablePropertySymbolsIn":["inheritedWritablePropertySymbols","writablePropertiesIn","writablePropertyNamesIn","writablePropertySymbols","propertySymbolsIn"],"writeFile":["exists","readFile"],"zip":["unzip"],"ztest":["ztest2"],"ztest2":["ztest"]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/datapackage.json b/lib/node_modules/@stdlib/namespace/alias2related/datapackage.json
new file mode 100644
index 000000000000..5d3ec7cd46ab
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/datapackage.json
@@ -0,0 +1,56 @@
+{
+ "name": "stdlib-alias2related",
+ "version": "",
+ "title": "Standard Library Aliases and Related Aliases",
+ "description": "A mapping between standard library aliases and related aliases.",
+ "resources": [
+ {
+ "name": "stdlib-alias2related-json",
+ "title": "Standard Library Aliases and Related Aliases",
+ "description": "A mapping between standard library aliases and related aliases.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-alias2related-csv",
+ "title": "Standard Library Aliases and Related Aliases",
+ "description": "A mapping between standard library aliases and related aliases.",
+ "format": "csv",
+ "mediatype": "plain/csv",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.csv",
+ "schema": {
+ "fields": [
+ {
+ "name": "alias",
+ "title": "Alias",
+ "description": "Alias.",
+ "type": "string",
+ "format": "default"
+ },
+ {
+ "name": "related",
+ "title": "Related",
+ "description": "Comma-delimited aliases.",
+ "type": "string",
+ "format": "default"
+ }
+ ]
+ }
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "stdlib",
+ "namespace",
+ "aliases",
+ "package",
+ "name",
+ "related"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/docs/repl.txt b/lib/node_modules/@stdlib/namespace/alias2related/docs/repl.txt
new file mode 100644
index 000000000000..90204c71a4e6
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/docs/repl.txt
@@ -0,0 +1,22 @@
+
+{{alias}}( alias )
+ Returns aliases related to a specified alias.
+
+ Parameters
+ ----------
+ alias: string
+ Alias.
+
+ Returns
+ -------
+ out: Array|null
+ Related aliases.
+
+ Examples
+ --------
+ > var v = {{alias}}( '{{alias:@stdlib/math/base/special/sin}}' )
+ [...]
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/docs/types/index.d.ts b/lib/node_modules/@stdlib/namespace/alias2related/docs/types/index.d.ts
new file mode 100644
index 000000000000..b318721fe068
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/docs/types/index.d.ts
@@ -0,0 +1,36 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns aliases related to a specified alias.
+*
+* @param alias - alias
+* @returns related aliases
+*
+* @example
+* var out = alias2related( 'base.sin' );
+* // returns [...]
+*/
+declare function alias2related( alias: string ): Array | null;
+
+
+// EXPORTS //
+
+export = alias2related;
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/docs/types/test.ts b/lib/node_modules/@stdlib/namespace/alias2related/docs/types/test.ts
new file mode 100644
index 000000000000..65b173c9416c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 alias2related = require( './index' );
+
+
+// TESTS //
+
+// The function returns an array of strings or null...
+{
+ alias2related( 'base.sin' ); // $ExpectType string[] | null
+}
+
+// The compiler throws an error if the function is not provided a string...
+{
+ alias2related( 5 ); // $ExpectError
+ alias2related( true ); // $ExpectError
+ alias2related( false ); // $ExpectError
+ alias2related( null ); // $ExpectError
+ alias2related( undefined ); // $ExpectError
+ alias2related( [] ); // $ExpectError
+ alias2related( {} ); // $ExpectError
+ alias2related( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ alias2related( 'base.sin', 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/docs/usage.txt b/lib/node_modules/@stdlib/namespace/alias2related/docs/usage.txt
new file mode 100644
index 000000000000..2cc2f8f19c0a
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-alias2related [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/etc/cli_opts.json b/lib/node_modules/@stdlib/namespace/alias2related/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/examples/index.js b/lib/node_modules/@stdlib/namespace/alias2related/examples/index.js
new file mode 100644
index 000000000000..fc82e93ebef7
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/examples/index.js
@@ -0,0 +1,38 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2related = require( './../lib' );
+
+var list;
+var len;
+var idx;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ console.log( 'alias: %s. related: %s.', v, alias2related( v ).join( ', ' ) );
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/lib/index.js b/lib/node_modules/@stdlib/namespace/alias2related/lib/index.js
new file mode 100644
index 000000000000..6fefbc7ad257
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/lib/index.js
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases related to a specified alias.
+*
+* @module @stdlib/namespace/alias2related
+*
+* @example
+* var alias2related = require( '@stdlib/namespace/alias2related' );
+*
+* var v = alias2related( 'base.sin' );
+* // returns [...]
+*/
+
+// MODULES //
+
+var alias2related = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = alias2related;
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/lib/main.js b/lib/node_modules/@stdlib/namespace/alias2related/lib/main.js
new file mode 100644
index 000000000000..ba8f92aede58
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/lib/main.js
@@ -0,0 +1,54 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var ALIAS_TO_RELATED = require( './../data/data.json' );
+
+
+// MAIN //
+
+/**
+* Returns aliases related to a specified alias.
+*
+* @param {string} alias - alias
+* @throws {TypeError} must provide a string
+* @returns {(Array|StringArray|null)} related aliases
+*
+* @example
+* var v = alias2related( 'base.sin' );
+* // returns [...]
+*/
+function alias2related( alias ) {
+ if ( !isString( alias ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + alias + '`.' );
+ }
+ if ( hasOwnProp( ALIAS_TO_RELATED, alias ) ) {
+ return ALIAS_TO_RELATED[ alias ].slice();
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = alias2related;
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/package.json b/lib/node_modules/@stdlib/namespace/alias2related/package.json
new file mode 100644
index 000000000000..424f8f90550f
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/package.json
@@ -0,0 +1,71 @@
+{
+ "name": "@stdlib/namespace/alias2related",
+ "version": "0.0.0",
+ "description": "Return aliases related to a specified alias.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-alias2related": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "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",
+ "standard",
+ "library",
+ "lib",
+ "aliases",
+ "alias",
+ "namespace",
+ "package",
+ "name",
+ "pkg",
+ "related",
+ "see",
+ "also"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/scripts/build.js b/lib/node_modules/@stdlib/namespace/alias2related/scripts/build.js
new file mode 100644
index 000000000000..93b8850273a8
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/scripts/build.js
@@ -0,0 +1,97 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var namespace = require( '@stdlib/namespace' );
+var pkg2alias = require( '@stdlib/namespace/pkg2alias' );
+var objectKeys = require( '@stdlib/utils/keys' );
+
+
+// VARIABLES //
+
+var debug = logger( 'namespace:alias2related:build' );
+
+// Output file paths:
+var OUTPUT_JSON = resolve( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_CSV = resolve( __dirname, '..', 'data', 'data.csv' );
+
+
+// FUNCTIONS //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var related;
+ var alias;
+ var fopts;
+ var keys;
+ var json;
+ var csv;
+ var tmp;
+ var ns;
+ var i;
+ var j;
+
+ debug( 'Extracting namespace alias data...' );
+ ns = namespace();
+ json = {};
+ for ( i = 0; i < ns.length; i++ ) {
+ related = ns[ i ].related.slice();
+ tmp = [];
+ for ( j = 0; j < related.length; j++ ) {
+ alias = pkg2alias( related[ j ] );
+ if ( alias ) {
+ tmp.push( alias );
+ } else {
+ console.error( 'WARNING: unable to resolve related alias `'+related[j]+'` for `'+ns[i].alias+'`.' ); // eslint-disable-line no-console
+ }
+ }
+ json[ ns[i].alias ] = tmp;
+ }
+
+ debug( 'Writing to JSON file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_JSON, JSON.stringify( json ), fopts );
+
+ debug( 'Writing to CSV file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ keys = objectKeys( json );
+ csv = '';
+ for ( i = 0; i < keys.length; i++ ) {
+ csv += keys[ i ] + ',"' + json[ keys[i] ].join( ',' ) + '"\n'; // Note: ensures trailing newline
+ }
+ writeFile( OUTPUT_CSV, csv, fopts );
+}
+
+
+// MAIN //
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/test/test.cli.js b/lib/node_modules/@stdlib/namespace/alias2related/test/test.cli.js
new file mode 100644
index 000000000000..17d69a7fc701
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/test/test.cli.js
@@ -0,0 +1,184 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints related aliases', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'base.sin'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ stdout = stdout.toString().split( '\n' );
+
+ // Greater than 1 in order to include the trailing newline:
+ t.strictEqual( stdout.length > 1, true, 'prints related aliases' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
+
+tape( 'if unable to resolve a package name, the command-line interface sets a non-zero exit code', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'fjaldfjadljfeoejreandfljasdfjadsfjs'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.pass( error.message );
+ t.strictEqual( error.code, 1, 'expected exit code' );
+ }
+ t.strictEqual( stdout.toString(), '', 'does not print to` stdout`' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/namespace/alias2related/test/test.js b/lib/node_modules/@stdlib/namespace/alias2related/test/test.js
new file mode 100644
index 000000000000..d8d6ec4cec2d
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/alias2related/test/test.js
@@ -0,0 +1,92 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( '@stdlib/namespace/aliases' );
+var DATA = require( './../data/data.json' );
+var alias2related = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof alias2related, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a string', function test( t ) {
+ var values;
+ 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() {
+ alias2related( value );
+ };
+ }
+});
+
+tape( 'the function returns related aliases', function test( t ) {
+ var expected;
+ var actual;
+ var list;
+ var i;
+
+ list = aliases();
+ for ( i = 0; i < list.length; i++ ) {
+ expected = DATA[ list[i] ];
+ actual = alias2related( list[i] );
+ t.deepEqual( actual, expected, 'returns expected value for '+list[i] );
+ }
+ t.end();
+});
+
+tape( 'the function returns `null` if provided an unrecognized alias', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ 'adfkaljdfdsafs',
+ 'adklfadjflajdslfjalsdf',
+ 'adflkajdlkfjasdlkfjsadlkfjlasdjflsdjfla'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.strictEqual( alias2related( values[ i ] ), null, 'returns expected value' );
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/aliases/LICENSE b/lib/node_modules/@stdlib/namespace/aliases/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/namespace/aliases/README.md b/lib/node_modules/@stdlib/namespace/aliases/README.md
new file mode 100644
index 000000000000..57a959451b61
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/README.md
@@ -0,0 +1,134 @@
+
+
+# Aliases
+
+> A list of standard library aliases.
+
+
+
+## Usage
+
+```javascript
+var aliases = require( '@stdlib/namespace/aliases' );
+```
+
+#### aliases()
+
+Returns a list of standard library aliases.
+
+```javascript
+var list = aliases();
+// returns [...]
+```
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+
+var list;
+var len;
+var idx;
+var i;
+
+list = aliases();
+len = list.length;
+
+// Select random aliases from the list...
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ console.log( list[ idx ] );
+}
+```
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+### Usage
+
+```text
+Usage: stdlib-aliases [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-aliases
+```
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
diff --git a/lib/node_modules/@stdlib/namespace/aliases/benchmark/benchmark.js b/lib/node_modules/@stdlib/namespace/aliases/benchmark/benchmark.js
new file mode 100644
index 000000000000..42c5e7751ae5
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/benchmark/benchmark.js
@@ -0,0 +1,48 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isStringArray = require( '@stdlib/assert/is-string-array' ).primitives;
+var pkg = require( './../package.json' ).name;
+var aliases = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var v;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = aliases();
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( !isStringArray( v ) ) {
+ b.fail( 'should return an array of strings' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/aliases/bin/cli b/lib/node_modules/@stdlib/namespace/aliases/bin/cli
new file mode 100755
index 000000000000..b1e852fc5cf7
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/bin/cli
@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 fs = require( 'fs' );
+var resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var stdout = require( '@stdlib/streams/node/stdout' );
+var CLI = require( '@stdlib/tools/cli' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var fpath;
+ var cli;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Resolve the data file path:
+ fpath = resolve( __dirname, '..', 'data', 'data.txt' );
+
+ // Print the data to stdout:
+ fs.createReadStream( fpath )
+ .pipe( stdout )
+ .on( 'close', onClose );
+
+ /**
+ * Exits the CLI.
+ *
+ * @private
+ */
+ function onClose() {
+ cli.exit( 0 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/aliases/data/data.json b/lib/node_modules/@stdlib/namespace/aliases/data/data.json
new file mode 100644
index 000000000000..a631d85e2b92
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/data/data.json
@@ -0,0 +1 @@
+["AFINN_96","AFINN_111","alias2pkg","alias2related","aliases","allocUnsafe","anova1","ANSCOMBES_QUARTET","any","anyBy","anyByAsync","anyByRight","anyByRightAsync","APERY","append","ARCH","argumentFunction","ARGV","array","array2buffer","array2iterator","array2iteratorRight","ArrayBuffer","arraybuffer2buffer","arrayCtors","arrayDataType","arrayDataTypes","arrayMinDataType","arrayNextDataType","arrayPromotionRules","arraySafeCasts","arraySameKindCasts","arrayShape","arrayStream","arrayview2iterator","arrayview2iteratorRight","AsyncIteratorSymbol","bartlettTest","base.abs","base.abs2","base.absdiff","base.absInt32","base.acos","base.acosh","base.acoth","base.acovercos","base.acoversin","base.ahavercos","base.ahaversin","base.asin","base.asinh","base.atan","base.atan2","base.atanh","base.avercos","base.aversin","base.bernoulli","base.besselj0","base.besselj1","base.bessely0","base.bessely1","base.beta","base.betainc","base.betaincinv","base.betaln","base.binet","base.binomcoef","base.binomcoefln","base.boxcox","base.boxcox1p","base.boxcox1pinv","base.boxcoxinv","base.cabs","base.cabs2","base.cadd","base.cbrt","base.cceil","base.cceiln","base.ccis","base.cdiv","base.ceil","base.ceil2","base.ceil10","base.ceilb","base.ceiln","base.ceilsd","base.cexp","base.cflipsign","base.cfloor","base.cfloorn","base.cinv","base.clamp","base.cmul","base.cneg","base.continuedFraction","base.copysign","base.cos","base.cosh","base.cosm1","base.cospi","base.covercos","base.coversin","base.cphase","base.cpolar","base.cround","base.croundn","base.csignum","base.csub","base.dasum","base.daxpy","base.dcopy","base.deg2rad","base.digamma","base.diracDelta","base.dists.arcsine.Arcsine","base.dists.arcsine.cdf","base.dists.arcsine.entropy","base.dists.arcsine.kurtosis","base.dists.arcsine.logcdf","base.dists.arcsine.logpdf","base.dists.arcsine.mean","base.dists.arcsine.median","base.dists.arcsine.mode","base.dists.arcsine.pdf","base.dists.arcsine.quantile","base.dists.arcsine.skewness","base.dists.arcsine.stdev","base.dists.arcsine.variance","base.dists.bernoulli.Bernoulli","base.dists.bernoulli.cdf","base.dists.bernoulli.entropy","base.dists.bernoulli.kurtosis","base.dists.bernoulli.mean","base.dists.bernoulli.median","base.dists.bernoulli.mgf","base.dists.bernoulli.mode","base.dists.bernoulli.pmf","base.dists.bernoulli.quantile","base.dists.bernoulli.skewness","base.dists.bernoulli.stdev","base.dists.bernoulli.variance","base.dists.beta.Beta","base.dists.beta.cdf","base.dists.beta.entropy","base.dists.beta.kurtosis","base.dists.beta.logcdf","base.dists.beta.logpdf","base.dists.beta.mean","base.dists.beta.median","base.dists.beta.mgf","base.dists.beta.mode","base.dists.beta.pdf","base.dists.beta.quantile","base.dists.beta.skewness","base.dists.beta.stdev","base.dists.beta.variance","base.dists.betaprime.BetaPrime","base.dists.betaprime.cdf","base.dists.betaprime.kurtosis","base.dists.betaprime.logcdf","base.dists.betaprime.logpdf","base.dists.betaprime.mean","base.dists.betaprime.mode","base.dists.betaprime.pdf","base.dists.betaprime.quantile","base.dists.betaprime.skewness","base.dists.betaprime.stdev","base.dists.betaprime.variance","base.dists.binomial.Binomial","base.dists.binomial.cdf","base.dists.binomial.entropy","base.dists.binomial.kurtosis","base.dists.binomial.logpmf","base.dists.binomial.mean","base.dists.binomial.median","base.dists.binomial.mgf","base.dists.binomial.mode","base.dists.binomial.pmf","base.dists.binomial.quantile","base.dists.binomial.skewness","base.dists.binomial.stdev","base.dists.binomial.variance","base.dists.cauchy.Cauchy","base.dists.cauchy.cdf","base.dists.cauchy.entropy","base.dists.cauchy.logcdf","base.dists.cauchy.logpdf","base.dists.cauchy.median","base.dists.cauchy.mode","base.dists.cauchy.pdf","base.dists.cauchy.quantile","base.dists.chi.cdf","base.dists.chi.Chi","base.dists.chi.entropy","base.dists.chi.kurtosis","base.dists.chi.logpdf","base.dists.chi.mean","base.dists.chi.mode","base.dists.chi.pdf","base.dists.chi.quantile","base.dists.chi.skewness","base.dists.chi.stdev","base.dists.chi.variance","base.dists.chisquare.cdf","base.dists.chisquare.ChiSquare","base.dists.chisquare.entropy","base.dists.chisquare.kurtosis","base.dists.chisquare.logpdf","base.dists.chisquare.mean","base.dists.chisquare.mgf","base.dists.chisquare.mode","base.dists.chisquare.pdf","base.dists.chisquare.quantile","base.dists.chisquare.skewness","base.dists.chisquare.stdev","base.dists.chisquare.variance","base.dists.cosine.cdf","base.dists.cosine.Cosine","base.dists.cosine.kurtosis","base.dists.cosine.logcdf","base.dists.cosine.logpdf","base.dists.cosine.mean","base.dists.cosine.median","base.dists.cosine.mgf","base.dists.cosine.mode","base.dists.cosine.pdf","base.dists.cosine.quantile","base.dists.cosine.skewness","base.dists.cosine.stdev","base.dists.cosine.variance","base.dists.degenerate.cdf","base.dists.degenerate.Degenerate","base.dists.degenerate.entropy","base.dists.degenerate.logcdf","base.dists.degenerate.logpdf","base.dists.degenerate.logpmf","base.dists.degenerate.mean","base.dists.degenerate.median","base.dists.degenerate.mgf","base.dists.degenerate.mode","base.dists.degenerate.pdf","base.dists.degenerate.pmf","base.dists.degenerate.quantile","base.dists.degenerate.stdev","base.dists.degenerate.variance","base.dists.discreteUniform.cdf","base.dists.discreteUniform.DiscreteUniform","base.dists.discreteUniform.kurtosis","base.dists.discreteUniform.logcdf","base.dists.discreteUniform.logpmf","base.dists.discreteUniform.mean","base.dists.discreteUniform.median","base.dists.discreteUniform.mgf","base.dists.discreteUniform.pmf","base.dists.discreteUniform.quantile","base.dists.discreteUniform.skewness","base.dists.discreteUniform.stdev","base.dists.discreteUniform.variance","base.dists.erlang.cdf","base.dists.erlang.entropy","base.dists.erlang.Erlang","base.dists.erlang.kurtosis","base.dists.erlang.logpdf","base.dists.erlang.mean","base.dists.erlang.mgf","base.dists.erlang.mode","base.dists.erlang.pdf","base.dists.erlang.quantile","base.dists.erlang.skewness","base.dists.erlang.stdev","base.dists.erlang.variance","base.dists.exponential.cdf","base.dists.exponential.entropy","base.dists.exponential.Exponential","base.dists.exponential.kurtosis","base.dists.exponential.logcdf","base.dists.exponential.logpdf","base.dists.exponential.mean","base.dists.exponential.median","base.dists.exponential.mgf","base.dists.exponential.mode","base.dists.exponential.pdf","base.dists.exponential.quantile","base.dists.exponential.skewness","base.dists.exponential.stdev","base.dists.exponential.variance","base.dists.f.cdf","base.dists.f.entropy","base.dists.f.F","base.dists.f.kurtosis","base.dists.f.mean","base.dists.f.mode","base.dists.f.pdf","base.dists.f.quantile","base.dists.f.skewness","base.dists.f.stdev","base.dists.f.variance","base.dists.frechet.cdf","base.dists.frechet.entropy","base.dists.frechet.Frechet","base.dists.frechet.kurtosis","base.dists.frechet.logcdf","base.dists.frechet.logpdf","base.dists.frechet.mean","base.dists.frechet.median","base.dists.frechet.mode","base.dists.frechet.pdf","base.dists.frechet.quantile","base.dists.frechet.skewness","base.dists.frechet.stdev","base.dists.frechet.variance","base.dists.gamma.cdf","base.dists.gamma.entropy","base.dists.gamma.Gamma","base.dists.gamma.kurtosis","base.dists.gamma.logpdf","base.dists.gamma.mean","base.dists.gamma.mgf","base.dists.gamma.mode","base.dists.gamma.pdf","base.dists.gamma.quantile","base.dists.gamma.skewness","base.dists.gamma.stdev","base.dists.gamma.variance","base.dists.geometric.cdf","base.dists.geometric.entropy","base.dists.geometric.Geometric","base.dists.geometric.kurtosis","base.dists.geometric.logcdf","base.dists.geometric.logpmf","base.dists.geometric.mean","base.dists.geometric.median","base.dists.geometric.mgf","base.dists.geometric.mode","base.dists.geometric.pmf","base.dists.geometric.quantile","base.dists.geometric.skewness","base.dists.geometric.stdev","base.dists.geometric.variance","base.dists.gumbel.cdf","base.dists.gumbel.entropy","base.dists.gumbel.Gumbel","base.dists.gumbel.kurtosis","base.dists.gumbel.logcdf","base.dists.gumbel.logpdf","base.dists.gumbel.mean","base.dists.gumbel.median","base.dists.gumbel.mgf","base.dists.gumbel.mode","base.dists.gumbel.pdf","base.dists.gumbel.quantile","base.dists.gumbel.skewness","base.dists.gumbel.stdev","base.dists.gumbel.variance","base.dists.hypergeometric.cdf","base.dists.hypergeometric.Hypergeometric","base.dists.hypergeometric.kurtosis","base.dists.hypergeometric.logpmf","base.dists.hypergeometric.mean","base.dists.hypergeometric.mode","base.dists.hypergeometric.pmf","base.dists.hypergeometric.quantile","base.dists.hypergeometric.skewness","base.dists.hypergeometric.stdev","base.dists.hypergeometric.variance","base.dists.invgamma.cdf","base.dists.invgamma.entropy","base.dists.invgamma.InvGamma","base.dists.invgamma.kurtosis","base.dists.invgamma.logpdf","base.dists.invgamma.mean","base.dists.invgamma.mode","base.dists.invgamma.pdf","base.dists.invgamma.quantile","base.dists.invgamma.skewness","base.dists.invgamma.stdev","base.dists.invgamma.variance","base.dists.kumaraswamy.cdf","base.dists.kumaraswamy.Kumaraswamy","base.dists.kumaraswamy.kurtosis","base.dists.kumaraswamy.logcdf","base.dists.kumaraswamy.logpdf","base.dists.kumaraswamy.mean","base.dists.kumaraswamy.median","base.dists.kumaraswamy.mode","base.dists.kumaraswamy.pdf","base.dists.kumaraswamy.quantile","base.dists.kumaraswamy.skewness","base.dists.kumaraswamy.stdev","base.dists.kumaraswamy.variance","base.dists.laplace.cdf","base.dists.laplace.entropy","base.dists.laplace.kurtosis","base.dists.laplace.Laplace","base.dists.laplace.logcdf","base.dists.laplace.logpdf","base.dists.laplace.mean","base.dists.laplace.median","base.dists.laplace.mgf","base.dists.laplace.mode","base.dists.laplace.pdf","base.dists.laplace.quantile","base.dists.laplace.skewness","base.dists.laplace.stdev","base.dists.laplace.variance","base.dists.levy.cdf","base.dists.levy.entropy","base.dists.levy.Levy","base.dists.levy.logcdf","base.dists.levy.logpdf","base.dists.levy.mean","base.dists.levy.median","base.dists.levy.mode","base.dists.levy.pdf","base.dists.levy.quantile","base.dists.levy.stdev","base.dists.levy.variance","base.dists.logistic.cdf","base.dists.logistic.entropy","base.dists.logistic.kurtosis","base.dists.logistic.logcdf","base.dists.logistic.Logistic","base.dists.logistic.logpdf","base.dists.logistic.mean","base.dists.logistic.median","base.dists.logistic.mgf","base.dists.logistic.mode","base.dists.logistic.pdf","base.dists.logistic.quantile","base.dists.logistic.skewness","base.dists.logistic.stdev","base.dists.logistic.variance","base.dists.lognormal.cdf","base.dists.lognormal.entropy","base.dists.lognormal.kurtosis","base.dists.lognormal.LogNormal","base.dists.lognormal.logpdf","base.dists.lognormal.mean","base.dists.lognormal.median","base.dists.lognormal.mode","base.dists.lognormal.pdf","base.dists.lognormal.quantile","base.dists.lognormal.skewness","base.dists.lognormal.stdev","base.dists.lognormal.variance","base.dists.negativeBinomial.cdf","base.dists.negativeBinomial.kurtosis","base.dists.negativeBinomial.logpmf","base.dists.negativeBinomial.mean","base.dists.negativeBinomial.mgf","base.dists.negativeBinomial.mode","base.dists.negativeBinomial.NegativeBinomial","base.dists.negativeBinomial.pmf","base.dists.negativeBinomial.quantile","base.dists.negativeBinomial.skewness","base.dists.negativeBinomial.stdev","base.dists.negativeBinomial.variance","base.dists.normal.cdf","base.dists.normal.entropy","base.dists.normal.kurtosis","base.dists.normal.logpdf","base.dists.normal.mean","base.dists.normal.median","base.dists.normal.mgf","base.dists.normal.mode","base.dists.normal.Normal","base.dists.normal.pdf","base.dists.normal.quantile","base.dists.normal.skewness","base.dists.normal.stdev","base.dists.normal.variance","base.dists.pareto1.cdf","base.dists.pareto1.entropy","base.dists.pareto1.kurtosis","base.dists.pareto1.logcdf","base.dists.pareto1.logpdf","base.dists.pareto1.mean","base.dists.pareto1.median","base.dists.pareto1.mode","base.dists.pareto1.Pareto1","base.dists.pareto1.pdf","base.dists.pareto1.quantile","base.dists.pareto1.skewness","base.dists.pareto1.variance","base.dists.poisson.cdf","base.dists.poisson.entropy","base.dists.poisson.kurtosis","base.dists.poisson.logpmf","base.dists.poisson.mean","base.dists.poisson.median","base.dists.poisson.mgf","base.dists.poisson.mode","base.dists.poisson.pmf","base.dists.poisson.Poisson","base.dists.poisson.quantile","base.dists.poisson.skewness","base.dists.poisson.stdev","base.dists.poisson.variance","base.dists.rayleigh.cdf","base.dists.rayleigh.entropy","base.dists.rayleigh.kurtosis","base.dists.rayleigh.logcdf","base.dists.rayleigh.logpdf","base.dists.rayleigh.mean","base.dists.rayleigh.median","base.dists.rayleigh.mgf","base.dists.rayleigh.mode","base.dists.rayleigh.pdf","base.dists.rayleigh.quantile","base.dists.rayleigh.Rayleigh","base.dists.rayleigh.skewness","base.dists.rayleigh.stdev","base.dists.rayleigh.variance","base.dists.t.cdf","base.dists.t.entropy","base.dists.t.kurtosis","base.dists.t.mean","base.dists.t.median","base.dists.t.mode","base.dists.t.pdf","base.dists.t.quantile","base.dists.t.skewness","base.dists.t.stdev","base.dists.t.T","base.dists.t.variance","base.dists.triangular.cdf","base.dists.triangular.entropy","base.dists.triangular.kurtosis","base.dists.triangular.logcdf","base.dists.triangular.logpdf","base.dists.triangular.mean","base.dists.triangular.median","base.dists.triangular.mgf","base.dists.triangular.mode","base.dists.triangular.pdf","base.dists.triangular.quantile","base.dists.triangular.skewness","base.dists.triangular.stdev","base.dists.triangular.Triangular","base.dists.triangular.variance","base.dists.uniform.cdf","base.dists.uniform.entropy","base.dists.uniform.kurtosis","base.dists.uniform.logcdf","base.dists.uniform.logpdf","base.dists.uniform.mean","base.dists.uniform.median","base.dists.uniform.mgf","base.dists.uniform.pdf","base.dists.uniform.quantile","base.dists.uniform.skewness","base.dists.uniform.stdev","base.dists.uniform.Uniform","base.dists.uniform.variance","base.dists.weibull.cdf","base.dists.weibull.entropy","base.dists.weibull.kurtosis","base.dists.weibull.logcdf","base.dists.weibull.logpdf","base.dists.weibull.mean","base.dists.weibull.median","base.dists.weibull.mgf","base.dists.weibull.mode","base.dists.weibull.pdf","base.dists.weibull.quantile","base.dists.weibull.skewness","base.dists.weibull.stdev","base.dists.weibull.variance","base.dists.weibull.Weibull","base.ellipe","base.ellipk","base.epsdiff","base.erf","base.erfc","base.erfcinv","base.erfinv","base.eta","base.evalpoly","base.evalrational","base.exp","base.exp2","base.exp10","base.expit","base.expm1","base.expm1rel","base.exponent","base.exponentf","base.factorial","base.factorialln","base.fallingFactorial","base.fibonacci","base.fibonacciIndex","base.fibpoly","base.flipsign","base.float32ToInt32","base.float32ToUint32","base.float64ToFloat32","base.float64ToInt32","base.float64ToUint32","base.floor","base.floor2","base.floor10","base.floorb","base.floorn","base.floorsd","base.fresnel","base.fresnelc","base.fresnels","base.frexp","base.fromBinaryString","base.fromBinaryStringf","base.fromBinaryStringUint8","base.fromBinaryStringUint16","base.fromBinaryStringUint32","base.fromWordf","base.fromWords","base.gamma","base.gamma1pm1","base.gammaDeltaRatio","base.gammainc","base.gammaincinv","base.gammaLanczosSum","base.gammaLanczosSumExpGScaled","base.gammaln","base.gasum","base.gaxpy","base.gcd","base.gcopy","base.getHighWord","base.getLowWord","base.hacovercos","base.hacoversin","base.havercos","base.haversin","base.heaviside","base.hermitepoly","base.hypot","base.imul","base.imuldw","base.int32ToUint32","base.inv","base.isEven","base.isEvenInt32","base.isFinite","base.isInfinite","base.isInteger","base.isnan","base.isNegativeInteger","base.isNegativeZero","base.isNonNegativeInteger","base.isNonPositiveInteger","base.isOdd","base.isOddInt32","base.isPositiveInteger","base.isPositiveZero","base.isPow2Uint32","base.isProbability","base.isSafeInteger","base.kernelBetainc","base.kernelBetaincinv","base.kernelCos","base.kernelSin","base.kernelTan","base.kroneckerDelta","base.lcm","base.ldexp","base.ln","base.log","base.log1mexp","base.log1p","base.log1pexp","base.log2","base.log10","base.logaddexp","base.logit","base.lucas","base.lucaspoly","base.max","base.maxabs","base.min","base.minabs","base.minmax","base.minmaxabs","base.modf","base.ndarray","base.ndarrayMemoized","base.negafibonacci","base.negalucas","base.nonfibonacci","base.normalize","base.normalizef","base.normhermitepoly","base.pdiff","base.polygamma","base.pow","base.powm1","base.rad2deg","base.ramp","base.random.arcsine","base.random.bernoulli","base.random.beta","base.random.betaprime","base.random.binomial","base.random.boxMuller","base.random.cauchy","base.random.chi","base.random.chisquare","base.random.cosine","base.random.discreteUniform","base.random.erlang","base.random.exponential","base.random.f","base.random.frechet","base.random.gamma","base.random.geometric","base.random.gumbel","base.random.hypergeometric","base.random.improvedZiggurat","base.random.invgamma","base.random.kumaraswamy","base.random.laplace","base.random.levy","base.random.logistic","base.random.lognormal","base.random.minstd","base.random.minstdShuffle","base.random.mt19937","base.random.negativeBinomial","base.random.normal","base.random.pareto1","base.random.poisson","base.random.randi","base.random.randn","base.random.randu","base.random.rayleigh","base.random.t","base.random.triangular","base.random.uniform","base.random.weibull","base.reldiff","base.rempio2","base.risingFactorial","base.rotl32","base.rotr32","base.round","base.round2","base.round10","base.roundb","base.roundn","base.roundsd","base.rsqrt","base.sasum","base.saxpy","base.scopy","base.setHighWord","base.setLowWord","base.sici","base.signbit","base.signbitf","base.significandf","base.signum","base.sin","base.sinc","base.sincos","base.sincospi","base.sinh","base.sinpi","base.spence","base.sqrt","base.sqrt1pm1","base.sumSeries","base.tan","base.tanh","base.toBinaryString","base.toBinaryStringf","base.toBinaryStringUint8","base.toBinaryStringUint16","base.toBinaryStringUint32","base.toWordf","base.toWords","base.trigamma","base.trunc","base.trunc2","base.trunc10","base.truncb","base.truncn","base.truncsd","base.uimul","base.uimuldw","base.uint32ToInt32","base.vercos","base.versin","base.wrap","base.xlog1py","base.xlogy","base.zeta","BERNDT_CPS_WAGES_1985","bifurcate","bifurcateBy","bifurcateByAsync","bifurcateIn","bifurcateOwn","binomialTest","Buffer","buffer2json","capitalize","capitalizeKeys","CATALAN","CBRT_EPS","chdir","chi2gof","circarray2iterator","circularArrayStream","CircularBuffer","CMUDICT","complex","Complex64","COMPLEX64_NUM_BYTES","Complex64Array","Complex128","COMPLEX128_NUM_BYTES","Complex128Array","compose","composeAsync","configdir","conj","constantFunction","constantStream","constructorName","contains","convertArray","convertArraySame","convertPath","copy","copyBuffer","countBy","countByAsync","curry","curryRight","cwd","DALE_CHALL_NEW","datasets","dayOfQuarter","dayOfYear","daysInMonth","daysInYear","debugSinkStream","debugStream","deepEqual","deepGet","deepHasOwnProp","deepHasProp","deepPluck","deepSet","defineMemoizedProperty","defineProperties","defineProperty","dirname","DoublyLinkedList","doUntil","doUntilAsync","doUntilEach","doUntilEachRight","doWhile","doWhileAsync","doWhileEach","doWhileEachRight","E","emptyStream","endsWith","enumerableProperties","enumerablePropertiesIn","enumerablePropertySymbols","enumerablePropertySymbolsIn","ENV","EPS","error2json","EULERGAMMA","every","everyBy","everyByAsync","everyByRight","everyByRightAsync","evil","exists","expandContractions","extname","fastmath.abs","fastmath.acosh","fastmath.ampbm","fastmath.asinh","fastmath.atanh","fastmath.hypot","fastmath.log2Uint32","fastmath.max","fastmath.min","fastmath.powint","fastmath.sqrtUint32","FEMALE_FIRST_NAMES_EN","FIFO","find","flattenArray","flattenObject","flignerTest","FLOAT16_CBRT_EPS","FLOAT16_EPS","FLOAT16_EXPONENT_BIAS","FLOAT16_MAX","FLOAT16_MAX_SAFE_INTEGER","FLOAT16_MIN_SAFE_INTEGER","FLOAT16_NINF","FLOAT16_NUM_BYTES","FLOAT16_PINF","FLOAT16_PRECISION","FLOAT16_SMALLEST_NORMAL","FLOAT16_SMALLEST_SUBNORMAL","FLOAT16_SQRT_EPS","FLOAT32_CBRT_EPS","FLOAT32_EPS","FLOAT32_EXPONENT_BIAS","FLOAT32_MAX","FLOAT32_MAX_SAFE_INTEGER","FLOAT32_MIN_SAFE_INTEGER","FLOAT32_NINF","FLOAT32_NUM_BYTES","FLOAT32_PINF","FLOAT32_PRECISION","FLOAT32_SMALLEST_NORMAL","FLOAT32_SMALLEST_SUBNORMAL","FLOAT32_SQRT_EPS","Float32Array","FLOAT64_EXPONENT_BIAS","FLOAT64_HIGH_WORD_EXPONENT_MASK","FLOAT64_HIGH_WORD_SIGNIFICAND_MASK","FLOAT64_MAX","FLOAT64_MAX_BASE2_EXPONENT","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","FLOAT64_MAX_BASE10_EXPONENT","FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MAX_LN","FLOAT64_MAX_SAFE_FIBONACCI","FLOAT64_MAX_SAFE_INTEGER","FLOAT64_MAX_SAFE_LUCAS","FLOAT64_MAX_SAFE_NTH_FIBONACCI","FLOAT64_MAX_SAFE_NTH_LUCAS","FLOAT64_MIN_BASE2_EXPONENT","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL","FLOAT64_MIN_BASE10_EXPONENT","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","FLOAT64_MIN_LN","FLOAT64_MIN_SAFE_INTEGER","FLOAT64_NUM_BYTES","FLOAT64_PRECISION","FLOAT64_SMALLEST_NORMAL","FLOAT64_SMALLEST_SUBNORMAL","Float64Array","forEach","forEachAsync","forEachRight","forEachRightAsync","forIn","forOwn","FOURTH_PI","FOURTH_ROOT_EPS","FRB_SF_WAGE_RIGIDITY","fromCodePoint","functionName","functionSequence","functionSequenceAsync","GAMMA_LANCZOS_G","getegid","geteuid","getgid","getGlobal","getPrototypeOf","getuid","GLAISHER","group","groupBy","groupByAsync","groupIn","groupOwn","HALF_LN2","HALF_PI","HARRISON_BOSTON_HOUSE_PRICES","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED","hasArrayBufferSupport","hasAsyncAwaitSupport","hasAsyncIteratorSymbolSupport","hasClassSupport","hasDefinePropertiesSupport","hasDefinePropertySupport","hasFloat32ArraySupport","hasFloat64ArraySupport","hasFunctionNameSupport","hasGeneratorSupport","hasInt8ArraySupport","hasInt16ArraySupport","hasInt32ArraySupport","hasIteratorSymbolSupport","hasMapSupport","hasNodeBufferSupport","hasOwnProp","hasProp","hasProxySupport","hasSetSupport","hasSharedArrayBufferSupport","hasSymbolSupport","hasToStringTagSupport","hasUint8ArraySupport","hasUint8ClampedArraySupport","hasUint16ArraySupport","hasUint32ArraySupport","hasWeakMapSupport","hasWeakSetSupport","hasWebAssemblySupport","HERNDON_VENUS_SEMIDIAMETERS","homedir","HOURS_IN_DAY","HOURS_IN_WEEK","hoursInMonth","hoursInYear","httpServer","identity","ifelse","ifelseAsync","ifthen","ifthenAsync","imag","IMG_ACANTHUS_MOLLIS","IMG_AIRPLANE_FROM_ABOVE","IMG_ALLIUM_OREOPHILUM","IMG_BLACK_CANYON","IMG_DUST_BOWL_HOME","IMG_FRENCH_ALPINE_LANDSCAPE","IMG_LOCOMOTION_HOUSE_CAT","IMG_LOCOMOTION_NUDE_MALE","IMG_MARCH_PASTORAL","IMG_NAGASAKI_BOATS","incrapcorr","incrcount","incrcovariance","incrcovmat","incrcv","increwmean","increwstdev","increwvariance","incrgmean","incrgrubbs","incrhmean","incrkmeans","incrkurtosis","incrmaape","incrmae","incrmapcorr","incrmape","incrmax","incrmaxabs","incrmcovariance","incrmcv","incrmda","incrme","incrmean","incrmeanabs","incrmeanabs2","incrmeanstdev","incrmeanvar","incrmgmean","incrmgrubbs","incrmhmean","incrmidrange","incrmin","incrminabs","incrminmax","incrminmaxabs","incrmmaape","incrmmae","incrmmape","incrmmax","incrmmaxabs","incrmmda","incrmme","incrmmean","incrmmeanabs","incrmmeanabs2","incrmmeanstdev","incrmmeanvar","incrmmidrange","incrmmin","incrmminabs","incrmminmax","incrmminmaxabs","incrmmpe","incrmmse","incrmpcorr","incrmpcorr2","incrmpcorrdist","incrmpe","incrmprod","incrmrange","incrmrmse","incrmrss","incrmse","incrmstdev","incrmsum","incrmsumabs","incrmsumabs2","incrmsummary","incrmsumprod","incrmvariance","incrmvmr","incrpcorr","incrpcorr2","incrpcorrdist","incrpcorrdistmat","incrpcorrmat","incrprod","incrrange","incrrmse","incrrss","incrskewness","incrspace","incrstdev","incrsum","incrsumabs","incrsumabs2","incrsummary","incrsumprod","incrvariance","incrvmr","incrwmean","ind2sub","indexOf","inherit","inheritedEnumerableProperties","inheritedEnumerablePropertySymbols","inheritedKeys","inheritedNonEnumerableProperties","inheritedNonEnumerablePropertyNames","inheritedNonEnumerablePropertySymbols","inheritedProperties","inheritedPropertyDescriptor","inheritedPropertyDescriptors","inheritedPropertyNames","inheritedPropertySymbols","inheritedWritableProperties","inheritedWritablePropertyNames","inheritedWritablePropertySymbols","inmap","inmapAsync","inmapRight","inmapRightAsync","inspectSinkStream","inspectStream","instanceOf","INT8_MAX","INT8_MIN","INT8_NUM_BYTES","Int8Array","INT16_MAX","INT16_MIN","INT16_NUM_BYTES","Int16Array","INT32_MAX","INT32_MIN","INT32_NUM_BYTES","Int32Array","IS_BIG_ENDIAN","IS_BROWSER","IS_DARWIN","IS_ELECTRON","IS_ELECTRON_MAIN","IS_ELECTRON_RENDERER","IS_LITTLE_ENDIAN","IS_NODE","IS_WEB_WORKER","IS_WINDOWS","isAbsolutePath","isAccessorProperty","isAccessorPropertyIn","isAlphagram","isAlphaNumeric","isAnagram","isArguments","isArray","isArrayArray","isArrayBuffer","isArrayLength","isArrayLike","isArrayLikeObject","isASCII","isBetween","isBetweenArray","isBinaryString","isBoolean","isBooleanArray","isBoxedPrimitive","isBuffer","isCapitalized","isCentrosymmetricMatrix","isCircular","isCircularArray","isCircularPlainObject","isCollection","isComplex","isComplex64","isComplex64Array","isComplex128","isComplex128Array","isComplexLike","isComplexTypedArray","isConfigurableProperty","isConfigurablePropertyIn","isDataProperty","isDataPropertyIn","isDateObject","isDigitString","isEmailAddress","isEmptyArray","isEmptyObject","isEmptyString","isEnumerableProperty","isEnumerablePropertyIn","isError","isEvalError","isEven","isFalsy","isFalsyArray","isFinite","isFiniteArray","isFloat32Array","isFloat64Array","isFunction","isFunctionArray","isGeneratorObject","isGeneratorObjectLike","isHexString","isInfinite","isInheritedProperty","isInt8Array","isInt16Array","isInt32Array","isInteger","isIntegerArray","isIterableLike","isIteratorLike","isJSON","isLeapYear","isLowercase","isMatrixLike","isMethod","isMethodIn","isNamedTypedTupleLike","isnan","isNaNArray","isNativeFunction","isndarrayLike","isNegativeInteger","isNegativeIntegerArray","isNegativeNumber","isNegativeNumberArray","isNegativeZero","isNodeBuiltin","isNodeDuplexStreamLike","isNodeReadableStreamLike","isNodeREPL","isNodeStreamLike","isNodeTransformStreamLike","isNodeWritableStreamLike","isNonConfigurableProperty","isNonConfigurablePropertyIn","isNonEnumerableProperty","isNonEnumerablePropertyIn","isNonNegativeInteger","isNonNegativeIntegerArray","isNonNegativeNumber","isNonNegativeNumberArray","isNonPositiveInteger","isNonPositiveIntegerArray","isNonPositiveNumber","isNonPositiveNumberArray","isNonSymmetricMatrix","isNull","isNullArray","isNumber","isNumberArray","isNumericArray","isObject","isObjectArray","isObjectLike","isOdd","isoWeeksInYear","isPersymmetricMatrix","isPlainObject","isPlainObjectArray","isPositiveInteger","isPositiveIntegerArray","isPositiveNumber","isPositiveNumberArray","isPositiveZero","isPrimitive","isPrimitiveArray","isPRNGLike","isProbability","isProbabilityArray","isPrototypeOf","isRangeError","isReadableProperty","isReadablePropertyIn","isReadOnlyProperty","isReadOnlyPropertyIn","isReadWriteProperty","isReadWritePropertyIn","isReferenceError","isRegExp","isRegExpString","isRelativePath","isSafeInteger","isSafeIntegerArray","isSameValue","isSameValueZero","isSharedArrayBuffer","isSkewCentrosymmetricMatrix","isSkewPersymmetricMatrix","isSkewSymmetricMatrix","isSquareMatrix","isStrictEqual","isString","isStringArray","isSymbol","isSymbolArray","isSymmetricMatrix","isSyntaxError","isTruthy","isTruthyArray","isTypedArray","isTypedArrayLength","isTypedArrayLike","isTypeError","isUint8Array","isUint8ClampedArray","isUint16Array","isUint32Array","isUNCPath","isUndefined","isUndefinedOrNull","isUnityProbabilityArray","isUppercase","isURI","isURIError","isVectorLike","isWhitespace","isWritableProperty","isWritablePropertyIn","isWriteOnlyProperty","isWriteOnlyPropertyIn","iterAdd","iterAdvance","iterAny","iterAnyBy","iterator2array","iterator2arrayview","iterator2arrayviewRight","iteratorStream","IteratorSymbol","iterawgn","iterawln","iterawun","iterBartlettHannPulse","iterBartlettPulse","iterConcat","iterConstant","iterCosineWave","iterCounter","itercugmean","itercuhmean","itercumax","itercumaxabs","itercumean","itercumeanabs","itercumeanabs2","itercumidrange","itercumin","itercuminabs","itercuprod","itercurange","itercusum","itercusumabs","itercusumabs2","iterDedupe","iterDedupeBy","iterDiracComb","iterDivide","iterEmpty","iterEvery","iterEveryBy","iterFibonacci","iterFill","iterFilter","iterFilterMap","iterFirst","iterFlatTopPulse","iterFlow","iterForEach","iterHannPulse","iterHead","iterIntersection","iterIntersectionByHash","iterLanczosPulse","iterLast","iterLength","iterMap","iterMapN","itermax","itermaxabs","itermean","itermeanabs","itermeanabs2","itermidrange","itermin","iterminabs","itermmax","itermmaxabs","itermmean","itermmeanabs","itermmeanabs2","itermmidrange","itermmin","itermminabs","iterMod","itermprod","itermrange","itermsum","itermsumabs","itermsumabs2","iterMultiply","iterNone","iterNoneBy","iterNonFibonacci","iterNth","iterPeriodicSinc","iterPipeline","iterPop","iterprod","iterPulse","iterPush","iterrange","iterReject","iterReplicate","iterReplicateBy","iterSawtoothWave","iterShift","iterSineWave","iterSlice","iterSome","iterSomeBy","iterSquareWave","iterstdev","iterSubtract","itersum","itersumabs","itersumabs2","iterThunk","iterTriangleWave","iterUnion","iterUnique","iterUniqueBy","iterUniqueByHash","iterUnshift","itervariance","joinStream","kde2d","keyBy","keyByRight","keysIn","kruskalTest","kstest","lda","LinkedList","linspace","LIU_NEGATIVE_OPINION_WORDS_EN","LIU_POSITIVE_OPINION_WORDS_EN","LN_HALF","LN_PI","LN_SQRT_TWO_PI","LN_TWO_PI","LN2","LN10","LOG2E","LOG10E","logspace","lowercase","lowercaseKeys","lowess","lpad","ltrim","MALE_FIRST_NAMES_EN","mapFun","mapFunAsync","mapKeys","mapKeysAsync","mapValues","mapValuesAsync","MAX_ARRAY_LENGTH","MAX_TYPED_ARRAY_LENGTH","memoize","merge","MILLISECONDS_IN_DAY","MILLISECONDS_IN_HOUR","MILLISECONDS_IN_MINUTE","MILLISECONDS_IN_SECOND","MILLISECONDS_IN_WEEK","MINARD_NAPOLEONS_MARCH","MINUTES_IN_DAY","MINUTES_IN_HOUR","MINUTES_IN_WEEK","minutesInMonth","minutesInYear","MOBY_DICK","MONTH_NAMES_EN","MONTHS_IN_YEAR","moveProperty","namedtypedtuple","nativeClass","ndarray","ndarrayCastingModes","ndarrayDataTypes","ndarrayIndexModes","ndarrayMemoized","ndarrayMinDataType","ndarrayNextDataType","ndarrayOrders","ndarrayPromotionRules","ndarraySafeCasts","ndarraySameKindCasts","NIGHTINGALES_ROSE","NINF","NODE_VERSION","none","noneBy","noneByAsync","noneByRight","noneByRightAsync","nonEnumerableProperties","nonEnumerablePropertiesIn","nonEnumerablePropertyNames","nonEnumerablePropertyNamesIn","nonEnumerablePropertySymbols","nonEnumerablePropertySymbolsIn","noop","now","NUM_CPUS","Number","objectEntries","objectEntriesIn","objectFromEntries","objectInverse","objectInverseBy","objectKeys","objectValues","objectValuesIn","omit","omitBy","onlineBinaryClassification","onlineSGDRegression","openURL","PACE_BOSTON_HOUSE_PRICES","pad","papply","papplyRight","parallel","parseJSON","PATH_DELIMITER","PATH_DELIMITER_POSIX","PATH_DELIMITER_WIN32","PATH_SEP","PATH_SEP_POSIX","PATH_SEP_WIN32","pcorrtest","percentEncode","PHI","PI","PI_SQUARED","pick","pickBy","PINF","pkg2alias","pkg2related","PLATFORM","plot","Plot","pluck","pop","prepend","properties","propertiesIn","propertyDescriptor","propertyDescriptorIn","propertyDescriptors","propertyDescriptorsIn","propertyNames","propertyNamesIn","propertySymbols","propertySymbolsIn","Proxy","push","quarterOfYear","random.iterators.arcsine","random.iterators.bernoulli","random.iterators.beta","random.iterators.betaprime","random.iterators.binomial","random.iterators.boxMuller","random.iterators.cauchy","random.iterators.chi","random.iterators.chisquare","random.iterators.cosine","random.iterators.discreteUniform","random.iterators.erlang","random.iterators.exponential","random.iterators.f","random.iterators.frechet","random.iterators.gamma","random.iterators.geometric","random.iterators.gumbel","random.iterators.hypergeometric","random.iterators.improvedZiggurat","random.iterators.invgamma","random.iterators.kumaraswamy","random.iterators.laplace","random.iterators.levy","random.iterators.logistic","random.iterators.lognormal","random.iterators.minstd","random.iterators.minstdShuffle","random.iterators.mt19937","random.iterators.negativeBinomial","random.iterators.normal","random.iterators.pareto1","random.iterators.poisson","random.iterators.randi","random.iterators.randn","random.iterators.randu","random.iterators.rayleigh","random.iterators.t","random.iterators.triangular","random.iterators.uniform","random.iterators.weibull","random.streams.arcsine","random.streams.bernoulli","random.streams.beta","random.streams.betaprime","random.streams.binomial","random.streams.boxMuller","random.streams.cauchy","random.streams.chi","random.streams.chisquare","random.streams.cosine","random.streams.discreteUniform","random.streams.erlang","random.streams.exponential","random.streams.f","random.streams.gamma","random.streams.geometric","random.streams.gumbel","random.streams.improvedZiggurat","random.streams.invgamma","random.streams.kumaraswamy","random.streams.laplace","random.streams.levy","random.streams.logistic","random.streams.lognormal","random.streams.minstd","random.streams.minstdShuffle","random.streams.mt19937","random.streams.negativeBinomial","random.streams.normal","random.streams.pareto1","random.streams.poisson","random.streams.randi","random.streams.randn","random.streams.randu","random.streams.rayleigh","random.streams.t","random.streams.uniform","random.streams.weibull","ranks","RE_BASENAME","RE_BASENAME_POSIX","RE_BASENAME_WINDOWS","RE_COLOR_HEXADECIMAL","RE_DECIMAL_NUMBER","RE_DIRNAME","RE_DIRNAME_POSIX","RE_DIRNAME_WINDOWS","RE_EOL","RE_EXTENDED_LENGTH_PATH","RE_EXTNAME","RE_EXTNAME_POSIX","RE_EXTNAME_WINDOWS","RE_FILENAME","RE_FILENAME_POSIX","RE_FILENAME_WINDOWS","RE_FUNCTION_NAME","RE_NATIVE_FUNCTION","RE_REGEXP","RE_UNC_PATH","RE_UTF16_SURROGATE_PAIR","RE_UTF16_UNPAIRED_SURROGATE","RE_WHITESPACE","readDir","readFile","readFileList","readJSON","readWASM","real","realmax","realmin","reduce","reduceAsync","reduceRight","reduceRightAsync","reFromString","reim","removeFirst","removeLast","removePunctuation","removeUTF8BOM","removeWords","rename","reorderArguments","repeat","replace","rescape","resolveParentPath","reverseArguments","reverseString","reviveBasePRNG","reviveBuffer","reviveComplex","reviveComplex64","reviveComplex128","reviveError","reviveTypedArray","rpad","rtrim","safeintmax","safeintmin","sample","SAVOY_STOPWORDS_FIN","SAVOY_STOPWORDS_FR","SAVOY_STOPWORDS_GER","SAVOY_STOPWORDS_IT","SAVOY_STOPWORDS_POR","SAVOY_STOPWORDS_SP","SAVOY_STOPWORDS_SWE","SECONDS_IN_DAY","SECONDS_IN_HOUR","SECONDS_IN_MINUTE","SECONDS_IN_WEEK","secondsInMonth","secondsInYear","setConfigurableReadOnly","setConfigurableReadOnlyAccessor","setConfigurableReadWriteAccessor","setConfigurableWriteOnlyAccessor","setMemoizedReadOnly","setNonEnumerableProperty","setNonEnumerableReadOnly","setNonEnumerableReadOnlyAccessor","setNonEnumerableReadWriteAccessor","setNonEnumerableWriteOnlyAccessor","setReadOnly","setReadOnlyAccessor","setReadWriteAccessor","setWriteOnlyAccessor","SharedArrayBuffer","shift","shuffle","sizeOf","some","someBy","someByAsync","someByRight","someByRightAsync","SOTU","SPACHE_REVISED","SPAM_ASSASSIN","SparklineBase","sparsearray2iterator","sparsearray2iteratorRight","splitStream","SQRT_EPS","SQRT_HALF","SQRT_HALF_PI","SQRT_PHI","SQRT_PI","SQRT_THREE","SQRT_TWO","SQRT_TWO_PI","Stack","startcase","startsWith","STOPWORDS_EN","stridedarray2iterator","stridedArrayStream","string2buffer","sub2ind","SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK","SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK","Symbol","tabulate","tabulateBy","tabulateByAsync","tic","timeit","tmpdir","toc","tokenize","transformStream","trim","trycatch","trycatchAsync","tryFunction","tryRequire","trythen","trythenAsync","ttest","ttest2","TWO_PI","typedarray","typedarray2json","typedarrayComplexCtors","typedarrayComplexDataTypes","typedarrayCtors","typedarrayDataTypes","typedarraypool","typemax","typemin","typeOf","UINT8_MAX","UINT8_NUM_BYTES","Uint8Array","Uint8ClampedArray","UINT16_MAX","UINT16_NUM_BYTES","Uint16Array","UINT32_MAX","UINT32_NUM_BYTES","Uint32Array","umask","uncapitalize","uncapitalizeKeys","uncurry","uncurryRight","UNICODE_MAX","UNICODE_MAX_BMP","UnicodeColumnChartSparkline","UnicodeLineChartSparkline","UnicodeSparkline","UnicodeTristateChartSparkline","UnicodeUpDownChartSparkline","UnicodeWinLossChartSparkline","unlink","unshift","until","untilAsync","untilEach","untilEachRight","unzip","uppercase","uppercaseKeys","US_STATES_ABBR","US_STATES_CAPITALS","US_STATES_CAPITALS_NAMES","US_STATES_NAMES","US_STATES_NAMES_CAPITALS","utf16ToUTF8Array","vartest","waterfall","whileAsync","whileEach","whileEachRight","whilst","writableProperties","writablePropertiesIn","writablePropertyNames","writablePropertyNamesIn","writablePropertySymbols","writablePropertySymbolsIn","writeFile","zip","ztest","ztest2"]
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/aliases/data/data.txt b/lib/node_modules/@stdlib/namespace/aliases/data/data.txt
new file mode 100644
index 000000000000..8b32e11826db
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/data/data.txt
@@ -0,0 +1,1894 @@
+AFINN_96
+AFINN_111
+alias2pkg
+alias2related
+aliases
+allocUnsafe
+anova1
+ANSCOMBES_QUARTET
+any
+anyBy
+anyByAsync
+anyByRight
+anyByRightAsync
+APERY
+append
+ARCH
+argumentFunction
+ARGV
+array
+array2buffer
+array2iterator
+array2iteratorRight
+ArrayBuffer
+arraybuffer2buffer
+arrayCtors
+arrayDataType
+arrayDataTypes
+arrayMinDataType
+arrayNextDataType
+arrayPromotionRules
+arraySafeCasts
+arraySameKindCasts
+arrayShape
+arrayStream
+arrayview2iterator
+arrayview2iteratorRight
+AsyncIteratorSymbol
+bartlettTest
+base.abs
+base.abs2
+base.absdiff
+base.absInt32
+base.acos
+base.acosh
+base.acoth
+base.acovercos
+base.acoversin
+base.ahavercos
+base.ahaversin
+base.asin
+base.asinh
+base.atan
+base.atan2
+base.atanh
+base.avercos
+base.aversin
+base.bernoulli
+base.besselj0
+base.besselj1
+base.bessely0
+base.bessely1
+base.beta
+base.betainc
+base.betaincinv
+base.betaln
+base.binet
+base.binomcoef
+base.binomcoefln
+base.boxcox
+base.boxcox1p
+base.boxcox1pinv
+base.boxcoxinv
+base.cabs
+base.cabs2
+base.cadd
+base.cbrt
+base.cceil
+base.cceiln
+base.ccis
+base.cdiv
+base.ceil
+base.ceil2
+base.ceil10
+base.ceilb
+base.ceiln
+base.ceilsd
+base.cexp
+base.cflipsign
+base.cfloor
+base.cfloorn
+base.cinv
+base.clamp
+base.cmul
+base.cneg
+base.continuedFraction
+base.copysign
+base.cos
+base.cosh
+base.cosm1
+base.cospi
+base.covercos
+base.coversin
+base.cphase
+base.cpolar
+base.cround
+base.croundn
+base.csignum
+base.csub
+base.dasum
+base.daxpy
+base.dcopy
+base.deg2rad
+base.digamma
+base.diracDelta
+base.dists.arcsine.Arcsine
+base.dists.arcsine.cdf
+base.dists.arcsine.entropy
+base.dists.arcsine.kurtosis
+base.dists.arcsine.logcdf
+base.dists.arcsine.logpdf
+base.dists.arcsine.mean
+base.dists.arcsine.median
+base.dists.arcsine.mode
+base.dists.arcsine.pdf
+base.dists.arcsine.quantile
+base.dists.arcsine.skewness
+base.dists.arcsine.stdev
+base.dists.arcsine.variance
+base.dists.bernoulli.Bernoulli
+base.dists.bernoulli.cdf
+base.dists.bernoulli.entropy
+base.dists.bernoulli.kurtosis
+base.dists.bernoulli.mean
+base.dists.bernoulli.median
+base.dists.bernoulli.mgf
+base.dists.bernoulli.mode
+base.dists.bernoulli.pmf
+base.dists.bernoulli.quantile
+base.dists.bernoulli.skewness
+base.dists.bernoulli.stdev
+base.dists.bernoulli.variance
+base.dists.beta.Beta
+base.dists.beta.cdf
+base.dists.beta.entropy
+base.dists.beta.kurtosis
+base.dists.beta.logcdf
+base.dists.beta.logpdf
+base.dists.beta.mean
+base.dists.beta.median
+base.dists.beta.mgf
+base.dists.beta.mode
+base.dists.beta.pdf
+base.dists.beta.quantile
+base.dists.beta.skewness
+base.dists.beta.stdev
+base.dists.beta.variance
+base.dists.betaprime.BetaPrime
+base.dists.betaprime.cdf
+base.dists.betaprime.kurtosis
+base.dists.betaprime.logcdf
+base.dists.betaprime.logpdf
+base.dists.betaprime.mean
+base.dists.betaprime.mode
+base.dists.betaprime.pdf
+base.dists.betaprime.quantile
+base.dists.betaprime.skewness
+base.dists.betaprime.stdev
+base.dists.betaprime.variance
+base.dists.binomial.Binomial
+base.dists.binomial.cdf
+base.dists.binomial.entropy
+base.dists.binomial.kurtosis
+base.dists.binomial.logpmf
+base.dists.binomial.mean
+base.dists.binomial.median
+base.dists.binomial.mgf
+base.dists.binomial.mode
+base.dists.binomial.pmf
+base.dists.binomial.quantile
+base.dists.binomial.skewness
+base.dists.binomial.stdev
+base.dists.binomial.variance
+base.dists.cauchy.Cauchy
+base.dists.cauchy.cdf
+base.dists.cauchy.entropy
+base.dists.cauchy.logcdf
+base.dists.cauchy.logpdf
+base.dists.cauchy.median
+base.dists.cauchy.mode
+base.dists.cauchy.pdf
+base.dists.cauchy.quantile
+base.dists.chi.cdf
+base.dists.chi.Chi
+base.dists.chi.entropy
+base.dists.chi.kurtosis
+base.dists.chi.logpdf
+base.dists.chi.mean
+base.dists.chi.mode
+base.dists.chi.pdf
+base.dists.chi.quantile
+base.dists.chi.skewness
+base.dists.chi.stdev
+base.dists.chi.variance
+base.dists.chisquare.cdf
+base.dists.chisquare.ChiSquare
+base.dists.chisquare.entropy
+base.dists.chisquare.kurtosis
+base.dists.chisquare.logpdf
+base.dists.chisquare.mean
+base.dists.chisquare.mgf
+base.dists.chisquare.mode
+base.dists.chisquare.pdf
+base.dists.chisquare.quantile
+base.dists.chisquare.skewness
+base.dists.chisquare.stdev
+base.dists.chisquare.variance
+base.dists.cosine.cdf
+base.dists.cosine.Cosine
+base.dists.cosine.kurtosis
+base.dists.cosine.logcdf
+base.dists.cosine.logpdf
+base.dists.cosine.mean
+base.dists.cosine.median
+base.dists.cosine.mgf
+base.dists.cosine.mode
+base.dists.cosine.pdf
+base.dists.cosine.quantile
+base.dists.cosine.skewness
+base.dists.cosine.stdev
+base.dists.cosine.variance
+base.dists.degenerate.cdf
+base.dists.degenerate.Degenerate
+base.dists.degenerate.entropy
+base.dists.degenerate.logcdf
+base.dists.degenerate.logpdf
+base.dists.degenerate.logpmf
+base.dists.degenerate.mean
+base.dists.degenerate.median
+base.dists.degenerate.mgf
+base.dists.degenerate.mode
+base.dists.degenerate.pdf
+base.dists.degenerate.pmf
+base.dists.degenerate.quantile
+base.dists.degenerate.stdev
+base.dists.degenerate.variance
+base.dists.discreteUniform.cdf
+base.dists.discreteUniform.DiscreteUniform
+base.dists.discreteUniform.kurtosis
+base.dists.discreteUniform.logcdf
+base.dists.discreteUniform.logpmf
+base.dists.discreteUniform.mean
+base.dists.discreteUniform.median
+base.dists.discreteUniform.mgf
+base.dists.discreteUniform.pmf
+base.dists.discreteUniform.quantile
+base.dists.discreteUniform.skewness
+base.dists.discreteUniform.stdev
+base.dists.discreteUniform.variance
+base.dists.erlang.cdf
+base.dists.erlang.entropy
+base.dists.erlang.Erlang
+base.dists.erlang.kurtosis
+base.dists.erlang.logpdf
+base.dists.erlang.mean
+base.dists.erlang.mgf
+base.dists.erlang.mode
+base.dists.erlang.pdf
+base.dists.erlang.quantile
+base.dists.erlang.skewness
+base.dists.erlang.stdev
+base.dists.erlang.variance
+base.dists.exponential.cdf
+base.dists.exponential.entropy
+base.dists.exponential.Exponential
+base.dists.exponential.kurtosis
+base.dists.exponential.logcdf
+base.dists.exponential.logpdf
+base.dists.exponential.mean
+base.dists.exponential.median
+base.dists.exponential.mgf
+base.dists.exponential.mode
+base.dists.exponential.pdf
+base.dists.exponential.quantile
+base.dists.exponential.skewness
+base.dists.exponential.stdev
+base.dists.exponential.variance
+base.dists.f.cdf
+base.dists.f.entropy
+base.dists.f.F
+base.dists.f.kurtosis
+base.dists.f.mean
+base.dists.f.mode
+base.dists.f.pdf
+base.dists.f.quantile
+base.dists.f.skewness
+base.dists.f.stdev
+base.dists.f.variance
+base.dists.frechet.cdf
+base.dists.frechet.entropy
+base.dists.frechet.Frechet
+base.dists.frechet.kurtosis
+base.dists.frechet.logcdf
+base.dists.frechet.logpdf
+base.dists.frechet.mean
+base.dists.frechet.median
+base.dists.frechet.mode
+base.dists.frechet.pdf
+base.dists.frechet.quantile
+base.dists.frechet.skewness
+base.dists.frechet.stdev
+base.dists.frechet.variance
+base.dists.gamma.cdf
+base.dists.gamma.entropy
+base.dists.gamma.Gamma
+base.dists.gamma.kurtosis
+base.dists.gamma.logpdf
+base.dists.gamma.mean
+base.dists.gamma.mgf
+base.dists.gamma.mode
+base.dists.gamma.pdf
+base.dists.gamma.quantile
+base.dists.gamma.skewness
+base.dists.gamma.stdev
+base.dists.gamma.variance
+base.dists.geometric.cdf
+base.dists.geometric.entropy
+base.dists.geometric.Geometric
+base.dists.geometric.kurtosis
+base.dists.geometric.logcdf
+base.dists.geometric.logpmf
+base.dists.geometric.mean
+base.dists.geometric.median
+base.dists.geometric.mgf
+base.dists.geometric.mode
+base.dists.geometric.pmf
+base.dists.geometric.quantile
+base.dists.geometric.skewness
+base.dists.geometric.stdev
+base.dists.geometric.variance
+base.dists.gumbel.cdf
+base.dists.gumbel.entropy
+base.dists.gumbel.Gumbel
+base.dists.gumbel.kurtosis
+base.dists.gumbel.logcdf
+base.dists.gumbel.logpdf
+base.dists.gumbel.mean
+base.dists.gumbel.median
+base.dists.gumbel.mgf
+base.dists.gumbel.mode
+base.dists.gumbel.pdf
+base.dists.gumbel.quantile
+base.dists.gumbel.skewness
+base.dists.gumbel.stdev
+base.dists.gumbel.variance
+base.dists.hypergeometric.cdf
+base.dists.hypergeometric.Hypergeometric
+base.dists.hypergeometric.kurtosis
+base.dists.hypergeometric.logpmf
+base.dists.hypergeometric.mean
+base.dists.hypergeometric.mode
+base.dists.hypergeometric.pmf
+base.dists.hypergeometric.quantile
+base.dists.hypergeometric.skewness
+base.dists.hypergeometric.stdev
+base.dists.hypergeometric.variance
+base.dists.invgamma.cdf
+base.dists.invgamma.entropy
+base.dists.invgamma.InvGamma
+base.dists.invgamma.kurtosis
+base.dists.invgamma.logpdf
+base.dists.invgamma.mean
+base.dists.invgamma.mode
+base.dists.invgamma.pdf
+base.dists.invgamma.quantile
+base.dists.invgamma.skewness
+base.dists.invgamma.stdev
+base.dists.invgamma.variance
+base.dists.kumaraswamy.cdf
+base.dists.kumaraswamy.Kumaraswamy
+base.dists.kumaraswamy.kurtosis
+base.dists.kumaraswamy.logcdf
+base.dists.kumaraswamy.logpdf
+base.dists.kumaraswamy.mean
+base.dists.kumaraswamy.median
+base.dists.kumaraswamy.mode
+base.dists.kumaraswamy.pdf
+base.dists.kumaraswamy.quantile
+base.dists.kumaraswamy.skewness
+base.dists.kumaraswamy.stdev
+base.dists.kumaraswamy.variance
+base.dists.laplace.cdf
+base.dists.laplace.entropy
+base.dists.laplace.kurtosis
+base.dists.laplace.Laplace
+base.dists.laplace.logcdf
+base.dists.laplace.logpdf
+base.dists.laplace.mean
+base.dists.laplace.median
+base.dists.laplace.mgf
+base.dists.laplace.mode
+base.dists.laplace.pdf
+base.dists.laplace.quantile
+base.dists.laplace.skewness
+base.dists.laplace.stdev
+base.dists.laplace.variance
+base.dists.levy.cdf
+base.dists.levy.entropy
+base.dists.levy.Levy
+base.dists.levy.logcdf
+base.dists.levy.logpdf
+base.dists.levy.mean
+base.dists.levy.median
+base.dists.levy.mode
+base.dists.levy.pdf
+base.dists.levy.quantile
+base.dists.levy.stdev
+base.dists.levy.variance
+base.dists.logistic.cdf
+base.dists.logistic.entropy
+base.dists.logistic.kurtosis
+base.dists.logistic.logcdf
+base.dists.logistic.Logistic
+base.dists.logistic.logpdf
+base.dists.logistic.mean
+base.dists.logistic.median
+base.dists.logistic.mgf
+base.dists.logistic.mode
+base.dists.logistic.pdf
+base.dists.logistic.quantile
+base.dists.logistic.skewness
+base.dists.logistic.stdev
+base.dists.logistic.variance
+base.dists.lognormal.cdf
+base.dists.lognormal.entropy
+base.dists.lognormal.kurtosis
+base.dists.lognormal.LogNormal
+base.dists.lognormal.logpdf
+base.dists.lognormal.mean
+base.dists.lognormal.median
+base.dists.lognormal.mode
+base.dists.lognormal.pdf
+base.dists.lognormal.quantile
+base.dists.lognormal.skewness
+base.dists.lognormal.stdev
+base.dists.lognormal.variance
+base.dists.negativeBinomial.cdf
+base.dists.negativeBinomial.kurtosis
+base.dists.negativeBinomial.logpmf
+base.dists.negativeBinomial.mean
+base.dists.negativeBinomial.mgf
+base.dists.negativeBinomial.mode
+base.dists.negativeBinomial.NegativeBinomial
+base.dists.negativeBinomial.pmf
+base.dists.negativeBinomial.quantile
+base.dists.negativeBinomial.skewness
+base.dists.negativeBinomial.stdev
+base.dists.negativeBinomial.variance
+base.dists.normal.cdf
+base.dists.normal.entropy
+base.dists.normal.kurtosis
+base.dists.normal.logpdf
+base.dists.normal.mean
+base.dists.normal.median
+base.dists.normal.mgf
+base.dists.normal.mode
+base.dists.normal.Normal
+base.dists.normal.pdf
+base.dists.normal.quantile
+base.dists.normal.skewness
+base.dists.normal.stdev
+base.dists.normal.variance
+base.dists.pareto1.cdf
+base.dists.pareto1.entropy
+base.dists.pareto1.kurtosis
+base.dists.pareto1.logcdf
+base.dists.pareto1.logpdf
+base.dists.pareto1.mean
+base.dists.pareto1.median
+base.dists.pareto1.mode
+base.dists.pareto1.Pareto1
+base.dists.pareto1.pdf
+base.dists.pareto1.quantile
+base.dists.pareto1.skewness
+base.dists.pareto1.variance
+base.dists.poisson.cdf
+base.dists.poisson.entropy
+base.dists.poisson.kurtosis
+base.dists.poisson.logpmf
+base.dists.poisson.mean
+base.dists.poisson.median
+base.dists.poisson.mgf
+base.dists.poisson.mode
+base.dists.poisson.pmf
+base.dists.poisson.Poisson
+base.dists.poisson.quantile
+base.dists.poisson.skewness
+base.dists.poisson.stdev
+base.dists.poisson.variance
+base.dists.rayleigh.cdf
+base.dists.rayleigh.entropy
+base.dists.rayleigh.kurtosis
+base.dists.rayleigh.logcdf
+base.dists.rayleigh.logpdf
+base.dists.rayleigh.mean
+base.dists.rayleigh.median
+base.dists.rayleigh.mgf
+base.dists.rayleigh.mode
+base.dists.rayleigh.pdf
+base.dists.rayleigh.quantile
+base.dists.rayleigh.Rayleigh
+base.dists.rayleigh.skewness
+base.dists.rayleigh.stdev
+base.dists.rayleigh.variance
+base.dists.t.cdf
+base.dists.t.entropy
+base.dists.t.kurtosis
+base.dists.t.mean
+base.dists.t.median
+base.dists.t.mode
+base.dists.t.pdf
+base.dists.t.quantile
+base.dists.t.skewness
+base.dists.t.stdev
+base.dists.t.T
+base.dists.t.variance
+base.dists.triangular.cdf
+base.dists.triangular.entropy
+base.dists.triangular.kurtosis
+base.dists.triangular.logcdf
+base.dists.triangular.logpdf
+base.dists.triangular.mean
+base.dists.triangular.median
+base.dists.triangular.mgf
+base.dists.triangular.mode
+base.dists.triangular.pdf
+base.dists.triangular.quantile
+base.dists.triangular.skewness
+base.dists.triangular.stdev
+base.dists.triangular.Triangular
+base.dists.triangular.variance
+base.dists.uniform.cdf
+base.dists.uniform.entropy
+base.dists.uniform.kurtosis
+base.dists.uniform.logcdf
+base.dists.uniform.logpdf
+base.dists.uniform.mean
+base.dists.uniform.median
+base.dists.uniform.mgf
+base.dists.uniform.pdf
+base.dists.uniform.quantile
+base.dists.uniform.skewness
+base.dists.uniform.stdev
+base.dists.uniform.Uniform
+base.dists.uniform.variance
+base.dists.weibull.cdf
+base.dists.weibull.entropy
+base.dists.weibull.kurtosis
+base.dists.weibull.logcdf
+base.dists.weibull.logpdf
+base.dists.weibull.mean
+base.dists.weibull.median
+base.dists.weibull.mgf
+base.dists.weibull.mode
+base.dists.weibull.pdf
+base.dists.weibull.quantile
+base.dists.weibull.skewness
+base.dists.weibull.stdev
+base.dists.weibull.variance
+base.dists.weibull.Weibull
+base.ellipe
+base.ellipk
+base.epsdiff
+base.erf
+base.erfc
+base.erfcinv
+base.erfinv
+base.eta
+base.evalpoly
+base.evalrational
+base.exp
+base.exp2
+base.exp10
+base.expit
+base.expm1
+base.expm1rel
+base.exponent
+base.exponentf
+base.factorial
+base.factorialln
+base.fallingFactorial
+base.fibonacci
+base.fibonacciIndex
+base.fibpoly
+base.flipsign
+base.float32ToInt32
+base.float32ToUint32
+base.float64ToFloat32
+base.float64ToInt32
+base.float64ToUint32
+base.floor
+base.floor2
+base.floor10
+base.floorb
+base.floorn
+base.floorsd
+base.fresnel
+base.fresnelc
+base.fresnels
+base.frexp
+base.fromBinaryString
+base.fromBinaryStringf
+base.fromBinaryStringUint8
+base.fromBinaryStringUint16
+base.fromBinaryStringUint32
+base.fromWordf
+base.fromWords
+base.gamma
+base.gamma1pm1
+base.gammaDeltaRatio
+base.gammainc
+base.gammaincinv
+base.gammaLanczosSum
+base.gammaLanczosSumExpGScaled
+base.gammaln
+base.gasum
+base.gaxpy
+base.gcd
+base.gcopy
+base.getHighWord
+base.getLowWord
+base.hacovercos
+base.hacoversin
+base.havercos
+base.haversin
+base.heaviside
+base.hermitepoly
+base.hypot
+base.imul
+base.imuldw
+base.int32ToUint32
+base.inv
+base.isEven
+base.isEvenInt32
+base.isFinite
+base.isInfinite
+base.isInteger
+base.isnan
+base.isNegativeInteger
+base.isNegativeZero
+base.isNonNegativeInteger
+base.isNonPositiveInteger
+base.isOdd
+base.isOddInt32
+base.isPositiveInteger
+base.isPositiveZero
+base.isPow2Uint32
+base.isProbability
+base.isSafeInteger
+base.kernelBetainc
+base.kernelBetaincinv
+base.kernelCos
+base.kernelSin
+base.kernelTan
+base.kroneckerDelta
+base.lcm
+base.ldexp
+base.ln
+base.log
+base.log1mexp
+base.log1p
+base.log1pexp
+base.log2
+base.log10
+base.logaddexp
+base.logit
+base.lucas
+base.lucaspoly
+base.max
+base.maxabs
+base.min
+base.minabs
+base.minmax
+base.minmaxabs
+base.modf
+base.ndarray
+base.ndarrayMemoized
+base.negafibonacci
+base.negalucas
+base.nonfibonacci
+base.normalize
+base.normalizef
+base.normhermitepoly
+base.pdiff
+base.polygamma
+base.pow
+base.powm1
+base.rad2deg
+base.ramp
+base.random.arcsine
+base.random.bernoulli
+base.random.beta
+base.random.betaprime
+base.random.binomial
+base.random.boxMuller
+base.random.cauchy
+base.random.chi
+base.random.chisquare
+base.random.cosine
+base.random.discreteUniform
+base.random.erlang
+base.random.exponential
+base.random.f
+base.random.frechet
+base.random.gamma
+base.random.geometric
+base.random.gumbel
+base.random.hypergeometric
+base.random.improvedZiggurat
+base.random.invgamma
+base.random.kumaraswamy
+base.random.laplace
+base.random.levy
+base.random.logistic
+base.random.lognormal
+base.random.minstd
+base.random.minstdShuffle
+base.random.mt19937
+base.random.negativeBinomial
+base.random.normal
+base.random.pareto1
+base.random.poisson
+base.random.randi
+base.random.randn
+base.random.randu
+base.random.rayleigh
+base.random.t
+base.random.triangular
+base.random.uniform
+base.random.weibull
+base.reldiff
+base.rempio2
+base.risingFactorial
+base.rotl32
+base.rotr32
+base.round
+base.round2
+base.round10
+base.roundb
+base.roundn
+base.roundsd
+base.rsqrt
+base.sasum
+base.saxpy
+base.scopy
+base.setHighWord
+base.setLowWord
+base.sici
+base.signbit
+base.signbitf
+base.significandf
+base.signum
+base.sin
+base.sinc
+base.sincos
+base.sincospi
+base.sinh
+base.sinpi
+base.spence
+base.sqrt
+base.sqrt1pm1
+base.sumSeries
+base.tan
+base.tanh
+base.toBinaryString
+base.toBinaryStringf
+base.toBinaryStringUint8
+base.toBinaryStringUint16
+base.toBinaryStringUint32
+base.toWordf
+base.toWords
+base.trigamma
+base.trunc
+base.trunc2
+base.trunc10
+base.truncb
+base.truncn
+base.truncsd
+base.uimul
+base.uimuldw
+base.uint32ToInt32
+base.vercos
+base.versin
+base.wrap
+base.xlog1py
+base.xlogy
+base.zeta
+BERNDT_CPS_WAGES_1985
+bifurcate
+bifurcateBy
+bifurcateByAsync
+bifurcateIn
+bifurcateOwn
+binomialTest
+Buffer
+buffer2json
+capitalize
+capitalizeKeys
+CATALAN
+CBRT_EPS
+chdir
+chi2gof
+circarray2iterator
+circularArrayStream
+CircularBuffer
+CMUDICT
+complex
+Complex64
+COMPLEX64_NUM_BYTES
+Complex64Array
+Complex128
+COMPLEX128_NUM_BYTES
+Complex128Array
+compose
+composeAsync
+configdir
+conj
+constantFunction
+constantStream
+constructorName
+contains
+convertArray
+convertArraySame
+convertPath
+copy
+copyBuffer
+countBy
+countByAsync
+curry
+curryRight
+cwd
+DALE_CHALL_NEW
+datasets
+dayOfQuarter
+dayOfYear
+daysInMonth
+daysInYear
+debugSinkStream
+debugStream
+deepEqual
+deepGet
+deepHasOwnProp
+deepHasProp
+deepPluck
+deepSet
+defineMemoizedProperty
+defineProperties
+defineProperty
+dirname
+DoublyLinkedList
+doUntil
+doUntilAsync
+doUntilEach
+doUntilEachRight
+doWhile
+doWhileAsync
+doWhileEach
+doWhileEachRight
+E
+emptyStream
+endsWith
+enumerableProperties
+enumerablePropertiesIn
+enumerablePropertySymbols
+enumerablePropertySymbolsIn
+ENV
+EPS
+error2json
+EULERGAMMA
+every
+everyBy
+everyByAsync
+everyByRight
+everyByRightAsync
+evil
+exists
+expandContractions
+extname
+fastmath.abs
+fastmath.acosh
+fastmath.ampbm
+fastmath.asinh
+fastmath.atanh
+fastmath.hypot
+fastmath.log2Uint32
+fastmath.max
+fastmath.min
+fastmath.powint
+fastmath.sqrtUint32
+FEMALE_FIRST_NAMES_EN
+FIFO
+find
+flattenArray
+flattenObject
+flignerTest
+FLOAT16_CBRT_EPS
+FLOAT16_EPS
+FLOAT16_EXPONENT_BIAS
+FLOAT16_MAX
+FLOAT16_MAX_SAFE_INTEGER
+FLOAT16_MIN_SAFE_INTEGER
+FLOAT16_NINF
+FLOAT16_NUM_BYTES
+FLOAT16_PINF
+FLOAT16_PRECISION
+FLOAT16_SMALLEST_NORMAL
+FLOAT16_SMALLEST_SUBNORMAL
+FLOAT16_SQRT_EPS
+FLOAT32_CBRT_EPS
+FLOAT32_EPS
+FLOAT32_EXPONENT_BIAS
+FLOAT32_MAX
+FLOAT32_MAX_SAFE_INTEGER
+FLOAT32_MIN_SAFE_INTEGER
+FLOAT32_NINF
+FLOAT32_NUM_BYTES
+FLOAT32_PINF
+FLOAT32_PRECISION
+FLOAT32_SMALLEST_NORMAL
+FLOAT32_SMALLEST_SUBNORMAL
+FLOAT32_SQRT_EPS
+Float32Array
+FLOAT64_EXPONENT_BIAS
+FLOAT64_HIGH_WORD_EXPONENT_MASK
+FLOAT64_HIGH_WORD_SIGNIFICAND_MASK
+FLOAT64_MAX
+FLOAT64_MAX_BASE2_EXPONENT
+FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL
+FLOAT64_MAX_BASE10_EXPONENT
+FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL
+FLOAT64_MAX_LN
+FLOAT64_MAX_SAFE_FIBONACCI
+FLOAT64_MAX_SAFE_INTEGER
+FLOAT64_MAX_SAFE_LUCAS
+FLOAT64_MAX_SAFE_NTH_FIBONACCI
+FLOAT64_MAX_SAFE_NTH_LUCAS
+FLOAT64_MIN_BASE2_EXPONENT
+FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL
+FLOAT64_MIN_BASE10_EXPONENT
+FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL
+FLOAT64_MIN_LN
+FLOAT64_MIN_SAFE_INTEGER
+FLOAT64_NUM_BYTES
+FLOAT64_PRECISION
+FLOAT64_SMALLEST_NORMAL
+FLOAT64_SMALLEST_SUBNORMAL
+Float64Array
+forEach
+forEachAsync
+forEachRight
+forEachRightAsync
+forIn
+forOwn
+FOURTH_PI
+FOURTH_ROOT_EPS
+FRB_SF_WAGE_RIGIDITY
+fromCodePoint
+functionName
+functionSequence
+functionSequenceAsync
+GAMMA_LANCZOS_G
+getegid
+geteuid
+getgid
+getGlobal
+getPrototypeOf
+getuid
+GLAISHER
+group
+groupBy
+groupByAsync
+groupIn
+groupOwn
+HALF_LN2
+HALF_PI
+HARRISON_BOSTON_HOUSE_PRICES
+HARRISON_BOSTON_HOUSE_PRICES_CORRECTED
+hasArrayBufferSupport
+hasAsyncAwaitSupport
+hasAsyncIteratorSymbolSupport
+hasClassSupport
+hasDefinePropertiesSupport
+hasDefinePropertySupport
+hasFloat32ArraySupport
+hasFloat64ArraySupport
+hasFunctionNameSupport
+hasGeneratorSupport
+hasInt8ArraySupport
+hasInt16ArraySupport
+hasInt32ArraySupport
+hasIteratorSymbolSupport
+hasMapSupport
+hasNodeBufferSupport
+hasOwnProp
+hasProp
+hasProxySupport
+hasSetSupport
+hasSharedArrayBufferSupport
+hasSymbolSupport
+hasToStringTagSupport
+hasUint8ArraySupport
+hasUint8ClampedArraySupport
+hasUint16ArraySupport
+hasUint32ArraySupport
+hasWeakMapSupport
+hasWeakSetSupport
+hasWebAssemblySupport
+HERNDON_VENUS_SEMIDIAMETERS
+homedir
+HOURS_IN_DAY
+HOURS_IN_WEEK
+hoursInMonth
+hoursInYear
+httpServer
+identity
+ifelse
+ifelseAsync
+ifthen
+ifthenAsync
+imag
+IMG_ACANTHUS_MOLLIS
+IMG_AIRPLANE_FROM_ABOVE
+IMG_ALLIUM_OREOPHILUM
+IMG_BLACK_CANYON
+IMG_DUST_BOWL_HOME
+IMG_FRENCH_ALPINE_LANDSCAPE
+IMG_LOCOMOTION_HOUSE_CAT
+IMG_LOCOMOTION_NUDE_MALE
+IMG_MARCH_PASTORAL
+IMG_NAGASAKI_BOATS
+incrapcorr
+incrcount
+incrcovariance
+incrcovmat
+incrcv
+increwmean
+increwstdev
+increwvariance
+incrgmean
+incrgrubbs
+incrhmean
+incrkmeans
+incrkurtosis
+incrmaape
+incrmae
+incrmapcorr
+incrmape
+incrmax
+incrmaxabs
+incrmcovariance
+incrmcv
+incrmda
+incrme
+incrmean
+incrmeanabs
+incrmeanabs2
+incrmeanstdev
+incrmeanvar
+incrmgmean
+incrmgrubbs
+incrmhmean
+incrmidrange
+incrmin
+incrminabs
+incrminmax
+incrminmaxabs
+incrmmaape
+incrmmae
+incrmmape
+incrmmax
+incrmmaxabs
+incrmmda
+incrmme
+incrmmean
+incrmmeanabs
+incrmmeanabs2
+incrmmeanstdev
+incrmmeanvar
+incrmmidrange
+incrmmin
+incrmminabs
+incrmminmax
+incrmminmaxabs
+incrmmpe
+incrmmse
+incrmpcorr
+incrmpcorr2
+incrmpcorrdist
+incrmpe
+incrmprod
+incrmrange
+incrmrmse
+incrmrss
+incrmse
+incrmstdev
+incrmsum
+incrmsumabs
+incrmsumabs2
+incrmsummary
+incrmsumprod
+incrmvariance
+incrmvmr
+incrpcorr
+incrpcorr2
+incrpcorrdist
+incrpcorrdistmat
+incrpcorrmat
+incrprod
+incrrange
+incrrmse
+incrrss
+incrskewness
+incrspace
+incrstdev
+incrsum
+incrsumabs
+incrsumabs2
+incrsummary
+incrsumprod
+incrvariance
+incrvmr
+incrwmean
+ind2sub
+indexOf
+inherit
+inheritedEnumerableProperties
+inheritedEnumerablePropertySymbols
+inheritedKeys
+inheritedNonEnumerableProperties
+inheritedNonEnumerablePropertyNames
+inheritedNonEnumerablePropertySymbols
+inheritedProperties
+inheritedPropertyDescriptor
+inheritedPropertyDescriptors
+inheritedPropertyNames
+inheritedPropertySymbols
+inheritedWritableProperties
+inheritedWritablePropertyNames
+inheritedWritablePropertySymbols
+inmap
+inmapAsync
+inmapRight
+inmapRightAsync
+inspectSinkStream
+inspectStream
+instanceOf
+INT8_MAX
+INT8_MIN
+INT8_NUM_BYTES
+Int8Array
+INT16_MAX
+INT16_MIN
+INT16_NUM_BYTES
+Int16Array
+INT32_MAX
+INT32_MIN
+INT32_NUM_BYTES
+Int32Array
+IS_BIG_ENDIAN
+IS_BROWSER
+IS_DARWIN
+IS_ELECTRON
+IS_ELECTRON_MAIN
+IS_ELECTRON_RENDERER
+IS_LITTLE_ENDIAN
+IS_NODE
+IS_WEB_WORKER
+IS_WINDOWS
+isAbsolutePath
+isAccessorProperty
+isAccessorPropertyIn
+isAlphagram
+isAlphaNumeric
+isAnagram
+isArguments
+isArray
+isArrayArray
+isArrayBuffer
+isArrayLength
+isArrayLike
+isArrayLikeObject
+isASCII
+isBetween
+isBetweenArray
+isBinaryString
+isBoolean
+isBooleanArray
+isBoxedPrimitive
+isBuffer
+isCapitalized
+isCentrosymmetricMatrix
+isCircular
+isCircularArray
+isCircularPlainObject
+isCollection
+isComplex
+isComplex64
+isComplex64Array
+isComplex128
+isComplex128Array
+isComplexLike
+isComplexTypedArray
+isConfigurableProperty
+isConfigurablePropertyIn
+isDataProperty
+isDataPropertyIn
+isDateObject
+isDigitString
+isEmailAddress
+isEmptyArray
+isEmptyObject
+isEmptyString
+isEnumerableProperty
+isEnumerablePropertyIn
+isError
+isEvalError
+isEven
+isFalsy
+isFalsyArray
+isFinite
+isFiniteArray
+isFloat32Array
+isFloat64Array
+isFunction
+isFunctionArray
+isGeneratorObject
+isGeneratorObjectLike
+isHexString
+isInfinite
+isInheritedProperty
+isInt8Array
+isInt16Array
+isInt32Array
+isInteger
+isIntegerArray
+isIterableLike
+isIteratorLike
+isJSON
+isLeapYear
+isLowercase
+isMatrixLike
+isMethod
+isMethodIn
+isNamedTypedTupleLike
+isnan
+isNaNArray
+isNativeFunction
+isndarrayLike
+isNegativeInteger
+isNegativeIntegerArray
+isNegativeNumber
+isNegativeNumberArray
+isNegativeZero
+isNodeBuiltin
+isNodeDuplexStreamLike
+isNodeReadableStreamLike
+isNodeREPL
+isNodeStreamLike
+isNodeTransformStreamLike
+isNodeWritableStreamLike
+isNonConfigurableProperty
+isNonConfigurablePropertyIn
+isNonEnumerableProperty
+isNonEnumerablePropertyIn
+isNonNegativeInteger
+isNonNegativeIntegerArray
+isNonNegativeNumber
+isNonNegativeNumberArray
+isNonPositiveInteger
+isNonPositiveIntegerArray
+isNonPositiveNumber
+isNonPositiveNumberArray
+isNonSymmetricMatrix
+isNull
+isNullArray
+isNumber
+isNumberArray
+isNumericArray
+isObject
+isObjectArray
+isObjectLike
+isOdd
+isoWeeksInYear
+isPersymmetricMatrix
+isPlainObject
+isPlainObjectArray
+isPositiveInteger
+isPositiveIntegerArray
+isPositiveNumber
+isPositiveNumberArray
+isPositiveZero
+isPrimitive
+isPrimitiveArray
+isPRNGLike
+isProbability
+isProbabilityArray
+isPrototypeOf
+isRangeError
+isReadableProperty
+isReadablePropertyIn
+isReadOnlyProperty
+isReadOnlyPropertyIn
+isReadWriteProperty
+isReadWritePropertyIn
+isReferenceError
+isRegExp
+isRegExpString
+isRelativePath
+isSafeInteger
+isSafeIntegerArray
+isSameValue
+isSameValueZero
+isSharedArrayBuffer
+isSkewCentrosymmetricMatrix
+isSkewPersymmetricMatrix
+isSkewSymmetricMatrix
+isSquareMatrix
+isStrictEqual
+isString
+isStringArray
+isSymbol
+isSymbolArray
+isSymmetricMatrix
+isSyntaxError
+isTruthy
+isTruthyArray
+isTypedArray
+isTypedArrayLength
+isTypedArrayLike
+isTypeError
+isUint8Array
+isUint8ClampedArray
+isUint16Array
+isUint32Array
+isUNCPath
+isUndefined
+isUndefinedOrNull
+isUnityProbabilityArray
+isUppercase
+isURI
+isURIError
+isVectorLike
+isWhitespace
+isWritableProperty
+isWritablePropertyIn
+isWriteOnlyProperty
+isWriteOnlyPropertyIn
+iterAdd
+iterAdvance
+iterAny
+iterAnyBy
+iterator2array
+iterator2arrayview
+iterator2arrayviewRight
+iteratorStream
+IteratorSymbol
+iterawgn
+iterawln
+iterawun
+iterBartlettHannPulse
+iterBartlettPulse
+iterConcat
+iterConstant
+iterCosineWave
+iterCounter
+itercugmean
+itercuhmean
+itercumax
+itercumaxabs
+itercumean
+itercumeanabs
+itercumeanabs2
+itercumidrange
+itercumin
+itercuminabs
+itercuprod
+itercurange
+itercusum
+itercusumabs
+itercusumabs2
+iterDedupe
+iterDedupeBy
+iterDiracComb
+iterDivide
+iterEmpty
+iterEvery
+iterEveryBy
+iterFibonacci
+iterFill
+iterFilter
+iterFilterMap
+iterFirst
+iterFlatTopPulse
+iterFlow
+iterForEach
+iterHannPulse
+iterHead
+iterIntersection
+iterIntersectionByHash
+iterLanczosPulse
+iterLast
+iterLength
+iterMap
+iterMapN
+itermax
+itermaxabs
+itermean
+itermeanabs
+itermeanabs2
+itermidrange
+itermin
+iterminabs
+itermmax
+itermmaxabs
+itermmean
+itermmeanabs
+itermmeanabs2
+itermmidrange
+itermmin
+itermminabs
+iterMod
+itermprod
+itermrange
+itermsum
+itermsumabs
+itermsumabs2
+iterMultiply
+iterNone
+iterNoneBy
+iterNonFibonacci
+iterNth
+iterPeriodicSinc
+iterPipeline
+iterPop
+iterprod
+iterPulse
+iterPush
+iterrange
+iterReject
+iterReplicate
+iterReplicateBy
+iterSawtoothWave
+iterShift
+iterSineWave
+iterSlice
+iterSome
+iterSomeBy
+iterSquareWave
+iterstdev
+iterSubtract
+itersum
+itersumabs
+itersumabs2
+iterThunk
+iterTriangleWave
+iterUnion
+iterUnique
+iterUniqueBy
+iterUniqueByHash
+iterUnshift
+itervariance
+joinStream
+kde2d
+keyBy
+keyByRight
+keysIn
+kruskalTest
+kstest
+lda
+LinkedList
+linspace
+LIU_NEGATIVE_OPINION_WORDS_EN
+LIU_POSITIVE_OPINION_WORDS_EN
+LN_HALF
+LN_PI
+LN_SQRT_TWO_PI
+LN_TWO_PI
+LN2
+LN10
+LOG2E
+LOG10E
+logspace
+lowercase
+lowercaseKeys
+lowess
+lpad
+ltrim
+MALE_FIRST_NAMES_EN
+mapFun
+mapFunAsync
+mapKeys
+mapKeysAsync
+mapValues
+mapValuesAsync
+MAX_ARRAY_LENGTH
+MAX_TYPED_ARRAY_LENGTH
+memoize
+merge
+MILLISECONDS_IN_DAY
+MILLISECONDS_IN_HOUR
+MILLISECONDS_IN_MINUTE
+MILLISECONDS_IN_SECOND
+MILLISECONDS_IN_WEEK
+MINARD_NAPOLEONS_MARCH
+MINUTES_IN_DAY
+MINUTES_IN_HOUR
+MINUTES_IN_WEEK
+minutesInMonth
+minutesInYear
+MOBY_DICK
+MONTH_NAMES_EN
+MONTHS_IN_YEAR
+moveProperty
+namedtypedtuple
+nativeClass
+ndarray
+ndarrayCastingModes
+ndarrayDataTypes
+ndarrayIndexModes
+ndarrayMemoized
+ndarrayMinDataType
+ndarrayNextDataType
+ndarrayOrders
+ndarrayPromotionRules
+ndarraySafeCasts
+ndarraySameKindCasts
+NIGHTINGALES_ROSE
+NINF
+NODE_VERSION
+none
+noneBy
+noneByAsync
+noneByRight
+noneByRightAsync
+nonEnumerableProperties
+nonEnumerablePropertiesIn
+nonEnumerablePropertyNames
+nonEnumerablePropertyNamesIn
+nonEnumerablePropertySymbols
+nonEnumerablePropertySymbolsIn
+noop
+now
+NUM_CPUS
+Number
+objectEntries
+objectEntriesIn
+objectFromEntries
+objectInverse
+objectInverseBy
+objectKeys
+objectValues
+objectValuesIn
+omit
+omitBy
+onlineBinaryClassification
+onlineSGDRegression
+openURL
+PACE_BOSTON_HOUSE_PRICES
+pad
+papply
+papplyRight
+parallel
+parseJSON
+PATH_DELIMITER
+PATH_DELIMITER_POSIX
+PATH_DELIMITER_WIN32
+PATH_SEP
+PATH_SEP_POSIX
+PATH_SEP_WIN32
+pcorrtest
+percentEncode
+PHI
+PI
+PI_SQUARED
+pick
+pickBy
+PINF
+pkg2alias
+pkg2related
+PLATFORM
+plot
+Plot
+pluck
+pop
+prepend
+properties
+propertiesIn
+propertyDescriptor
+propertyDescriptorIn
+propertyDescriptors
+propertyDescriptorsIn
+propertyNames
+propertyNamesIn
+propertySymbols
+propertySymbolsIn
+Proxy
+push
+quarterOfYear
+random.iterators.arcsine
+random.iterators.bernoulli
+random.iterators.beta
+random.iterators.betaprime
+random.iterators.binomial
+random.iterators.boxMuller
+random.iterators.cauchy
+random.iterators.chi
+random.iterators.chisquare
+random.iterators.cosine
+random.iterators.discreteUniform
+random.iterators.erlang
+random.iterators.exponential
+random.iterators.f
+random.iterators.frechet
+random.iterators.gamma
+random.iterators.geometric
+random.iterators.gumbel
+random.iterators.hypergeometric
+random.iterators.improvedZiggurat
+random.iterators.invgamma
+random.iterators.kumaraswamy
+random.iterators.laplace
+random.iterators.levy
+random.iterators.logistic
+random.iterators.lognormal
+random.iterators.minstd
+random.iterators.minstdShuffle
+random.iterators.mt19937
+random.iterators.negativeBinomial
+random.iterators.normal
+random.iterators.pareto1
+random.iterators.poisson
+random.iterators.randi
+random.iterators.randn
+random.iterators.randu
+random.iterators.rayleigh
+random.iterators.t
+random.iterators.triangular
+random.iterators.uniform
+random.iterators.weibull
+random.streams.arcsine
+random.streams.bernoulli
+random.streams.beta
+random.streams.betaprime
+random.streams.binomial
+random.streams.boxMuller
+random.streams.cauchy
+random.streams.chi
+random.streams.chisquare
+random.streams.cosine
+random.streams.discreteUniform
+random.streams.erlang
+random.streams.exponential
+random.streams.f
+random.streams.gamma
+random.streams.geometric
+random.streams.gumbel
+random.streams.improvedZiggurat
+random.streams.invgamma
+random.streams.kumaraswamy
+random.streams.laplace
+random.streams.levy
+random.streams.logistic
+random.streams.lognormal
+random.streams.minstd
+random.streams.minstdShuffle
+random.streams.mt19937
+random.streams.negativeBinomial
+random.streams.normal
+random.streams.pareto1
+random.streams.poisson
+random.streams.randi
+random.streams.randn
+random.streams.randu
+random.streams.rayleigh
+random.streams.t
+random.streams.uniform
+random.streams.weibull
+ranks
+RE_BASENAME
+RE_BASENAME_POSIX
+RE_BASENAME_WINDOWS
+RE_COLOR_HEXADECIMAL
+RE_DECIMAL_NUMBER
+RE_DIRNAME
+RE_DIRNAME_POSIX
+RE_DIRNAME_WINDOWS
+RE_EOL
+RE_EXTENDED_LENGTH_PATH
+RE_EXTNAME
+RE_EXTNAME_POSIX
+RE_EXTNAME_WINDOWS
+RE_FILENAME
+RE_FILENAME_POSIX
+RE_FILENAME_WINDOWS
+RE_FUNCTION_NAME
+RE_NATIVE_FUNCTION
+RE_REGEXP
+RE_UNC_PATH
+RE_UTF16_SURROGATE_PAIR
+RE_UTF16_UNPAIRED_SURROGATE
+RE_WHITESPACE
+readDir
+readFile
+readFileList
+readJSON
+readWASM
+real
+realmax
+realmin
+reduce
+reduceAsync
+reduceRight
+reduceRightAsync
+reFromString
+reim
+removeFirst
+removeLast
+removePunctuation
+removeUTF8BOM
+removeWords
+rename
+reorderArguments
+repeat
+replace
+rescape
+resolveParentPath
+reverseArguments
+reverseString
+reviveBasePRNG
+reviveBuffer
+reviveComplex
+reviveComplex64
+reviveComplex128
+reviveError
+reviveTypedArray
+rpad
+rtrim
+safeintmax
+safeintmin
+sample
+SAVOY_STOPWORDS_FIN
+SAVOY_STOPWORDS_FR
+SAVOY_STOPWORDS_GER
+SAVOY_STOPWORDS_IT
+SAVOY_STOPWORDS_POR
+SAVOY_STOPWORDS_SP
+SAVOY_STOPWORDS_SWE
+SECONDS_IN_DAY
+SECONDS_IN_HOUR
+SECONDS_IN_MINUTE
+SECONDS_IN_WEEK
+secondsInMonth
+secondsInYear
+setConfigurableReadOnly
+setConfigurableReadOnlyAccessor
+setConfigurableReadWriteAccessor
+setConfigurableWriteOnlyAccessor
+setMemoizedReadOnly
+setNonEnumerableProperty
+setNonEnumerableReadOnly
+setNonEnumerableReadOnlyAccessor
+setNonEnumerableReadWriteAccessor
+setNonEnumerableWriteOnlyAccessor
+setReadOnly
+setReadOnlyAccessor
+setReadWriteAccessor
+setWriteOnlyAccessor
+SharedArrayBuffer
+shift
+shuffle
+sizeOf
+some
+someBy
+someByAsync
+someByRight
+someByRightAsync
+SOTU
+SPACHE_REVISED
+SPAM_ASSASSIN
+SparklineBase
+sparsearray2iterator
+sparsearray2iteratorRight
+splitStream
+SQRT_EPS
+SQRT_HALF
+SQRT_HALF_PI
+SQRT_PHI
+SQRT_PI
+SQRT_THREE
+SQRT_TWO
+SQRT_TWO_PI
+Stack
+startcase
+startsWith
+STOPWORDS_EN
+stridedarray2iterator
+stridedArrayStream
+string2buffer
+sub2ind
+SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK
+SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK
+Symbol
+tabulate
+tabulateBy
+tabulateByAsync
+tic
+timeit
+tmpdir
+toc
+tokenize
+transformStream
+trim
+trycatch
+trycatchAsync
+tryFunction
+tryRequire
+trythen
+trythenAsync
+ttest
+ttest2
+TWO_PI
+typedarray
+typedarray2json
+typedarrayComplexCtors
+typedarrayComplexDataTypes
+typedarrayCtors
+typedarrayDataTypes
+typedarraypool
+typemax
+typemin
+typeOf
+UINT8_MAX
+UINT8_NUM_BYTES
+Uint8Array
+Uint8ClampedArray
+UINT16_MAX
+UINT16_NUM_BYTES
+Uint16Array
+UINT32_MAX
+UINT32_NUM_BYTES
+Uint32Array
+umask
+uncapitalize
+uncapitalizeKeys
+uncurry
+uncurryRight
+UNICODE_MAX
+UNICODE_MAX_BMP
+UnicodeColumnChartSparkline
+UnicodeLineChartSparkline
+UnicodeSparkline
+UnicodeTristateChartSparkline
+UnicodeUpDownChartSparkline
+UnicodeWinLossChartSparkline
+unlink
+unshift
+until
+untilAsync
+untilEach
+untilEachRight
+unzip
+uppercase
+uppercaseKeys
+US_STATES_ABBR
+US_STATES_CAPITALS
+US_STATES_CAPITALS_NAMES
+US_STATES_NAMES
+US_STATES_NAMES_CAPITALS
+utf16ToUTF8Array
+vartest
+waterfall
+whileAsync
+whileEach
+whileEachRight
+whilst
+writableProperties
+writablePropertiesIn
+writablePropertyNames
+writablePropertyNamesIn
+writablePropertySymbols
+writablePropertySymbolsIn
+writeFile
+zip
+ztest
+ztest2
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/aliases/datapackage.json b/lib/node_modules/@stdlib/namespace/aliases/datapackage.json
new file mode 100644
index 000000000000..60c924142cf9
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/datapackage.json
@@ -0,0 +1,36 @@
+{
+ "name": "stdlib-aliases",
+ "version": "",
+ "title": "Standard Library Aliases",
+ "description": "A list of standard library aliases.",
+ "resources": [
+ {
+ "name": "stdlib-aliases-json",
+ "title": "Standard Library Aliases",
+ "description": "A list of standard library aliases.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-aliases-txt",
+ "title": "Standard Library Aliases",
+ "description": "A list of standard library aliases.",
+ "format": "text",
+ "mediatype": "plain/text",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.txt"
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "list",
+ "stdlib",
+ "namespace",
+ "aliases"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/namespace/aliases/docs/repl.txt b/lib/node_modules/@stdlib/namespace/aliases/docs/repl.txt
new file mode 100644
index 000000000000..9822a8e42450
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/docs/repl.txt
@@ -0,0 +1,17 @@
+
+{{alias}}()
+ Returns a list of standard library aliases.
+
+ Returns
+ -------
+ out: Array
+ List of aliases.
+
+ Examples
+ --------
+ > var o = {{alias}}()
+ [...]
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/namespace/aliases/docs/types/index.d.ts b/lib/node_modules/@stdlib/namespace/aliases/docs/types/index.d.ts
new file mode 100644
index 000000000000..7e9fde35186f
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/docs/types/index.d.ts
@@ -0,0 +1,35 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns a list of standard library aliases.
+*
+* @returns list of aliases
+*
+* @example
+* var list = aliases();
+* // returns [...]
+*/
+declare function aliases(): Array;
+
+
+// EXPORTS //
+
+export = aliases;
diff --git a/lib/node_modules/@stdlib/namespace/aliases/docs/types/test.ts b/lib/node_modules/@stdlib/namespace/aliases/docs/types/test.ts
new file mode 100644
index 000000000000..d39061c04ee9
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/docs/types/test.ts
@@ -0,0 +1,32 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( './index' );
+
+
+// TESTS //
+
+// The function returns an array of strings...
+{
+ aliases(); // $ExpectType string[]
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ aliases( 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/namespace/aliases/docs/usage.txt b/lib/node_modules/@stdlib/namespace/aliases/docs/usage.txt
new file mode 100644
index 000000000000..3dc63abb2069
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-aliases [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/namespace/aliases/etc/cli_opts.json b/lib/node_modules/@stdlib/namespace/aliases/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/namespace/aliases/examples/index.js b/lib/node_modules/@stdlib/namespace/aliases/examples/index.js
new file mode 100644
index 000000000000..2aeaf8ab6f09
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/examples/index.js
@@ -0,0 +1,36 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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/base/discrete-uniform' );
+var aliases = require( './../lib' );
+
+var list;
+var len;
+var idx;
+var i;
+
+list = aliases();
+len = list.length;
+
+// Select random aliases from the list...
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ console.log( list[ idx ] );
+}
diff --git a/lib/node_modules/@stdlib/namespace/aliases/lib/index.js b/lib/node_modules/@stdlib/namespace/aliases/lib/index.js
new file mode 100644
index 000000000000..d97266ba6e22
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/lib/index.js
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+/**
+* Standard library aliases.
+*
+* @module @stdlib/namespace/aliases
+*
+* @example
+* var aliases = require( '@stdlib/namespace/aliases' );
+*
+* var list = aliases();
+* // returns [...]
+*/
+
+// MODULES //
+
+var aliases = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = aliases;
diff --git a/lib/node_modules/@stdlib/namespace/aliases/lib/main.js b/lib/node_modules/@stdlib/namespace/aliases/lib/main.js
new file mode 100644
index 000000000000..0d67f790b4a1
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/lib/main.js
@@ -0,0 +1,44 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 ALIASES = require( './../data/data.json' );
+
+
+// MAIN //
+
+/**
+* Returns a list of standard library aliases.
+*
+* @returns {StringArray} list of aliases
+*
+* @example
+* var list = aliases();
+* // returns [...]
+*/
+function aliases() {
+ return ALIASES.slice();
+}
+
+
+// EXPORTS //
+
+module.exports = aliases;
diff --git a/lib/node_modules/@stdlib/namespace/aliases/package.json b/lib/node_modules/@stdlib/namespace/aliases/package.json
new file mode 100644
index 000000000000..7ce88feacd4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@stdlib/namespace/aliases",
+ "version": "0.0.0",
+ "description": "Standard library aliases.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-aliases": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "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",
+ "standard",
+ "library",
+ "lib",
+ "aliases",
+ "alias",
+ "namespace",
+ "dataset",
+ "data"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/namespace/aliases/scripts/build.js b/lib/node_modules/@stdlib/namespace/aliases/scripts/build.js
new file mode 100644
index 000000000000..3bbb1eb081da
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/scripts/build.js
@@ -0,0 +1,74 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var namespace = require( '@stdlib/namespace' );
+
+
+// VARIABLES //
+
+var debug = logger( 'namespace:aliases:build' );
+
+// Output file paths:
+var OUTPUT_JSON = resolve( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_TEXT = resolve( __dirname, '..', 'data', 'data.txt' );
+
+
+// FUNCTIONS //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var fopts;
+ var list;
+ var ns;
+ var i;
+
+ debug( 'Extracting list of namespace aliases...' );
+ ns = namespace();
+ list = [];
+ for ( i = 0; i < ns.length; i++ ) {
+ list.push( ns[ i ].alias );
+ }
+
+ debug( 'Writing list of namespace aliases to JSON file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_JSON, JSON.stringify( list ), fopts );
+
+ debug( 'Writing list of namespace aliases to text file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_TEXT, list.join( '\n' ), fopts );
+}
+
+
+// MAIN //
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/aliases/test/test.cli.js b/lib/node_modules/@stdlib/namespace/aliases/test/test.cli.js
new file mode 100644
index 000000000000..152515d239e7
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/test/test.cli.js
@@ -0,0 +1,167 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints the list of aliases', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ cmd = [
+ process.execPath,
+ fpath
+ ];
+
+ expected = readFileSync( resolve( __dirname, '..', 'data', 'data.txt' ) );
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ stdout = stdout.toString();
+ expected = expected.toString();
+ t.strictEqual( stdout, expected, 'prints expected values' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/namespace/aliases/test/test.js b/lib/node_modules/@stdlib/namespace/aliases/test/test.js
new file mode 100644
index 000000000000..7dda3a515ea1
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/aliases/test/test.js
@@ -0,0 +1,48 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isStringArray = require( '@stdlib/assert/is-string-array' ).primitives;
+var aliases = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof aliases, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function returns a list of aliases', function test( t ) {
+ var o1;
+ var o2;
+
+ o1 = aliases();
+ t.strictEqual( isStringArray( o1 ), true, 'returns an array of strings' );
+
+ o2 = aliases();
+ t.strictEqual( isStringArray( o2 ), true, 'returns an array of strings' );
+ t.notEqual( o1, o2, 'returns new reference' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/lib/namespace/a.js b/lib/node_modules/@stdlib/namespace/lib/namespace/a.js
index 31ada5d119b7..bd4097905154 100644
--- a/lib/node_modules/@stdlib/namespace/lib/namespace/a.js
+++ b/lib/node_modules/@stdlib/namespace/lib/namespace/a.js
@@ -46,6 +46,42 @@ ns.push({
]
});
+ns.push({
+ 'alias': 'alias2pkg',
+ 'path': '@stdlib/namespace/alias2pkg',
+ 'value': require( '@stdlib/namespace/alias2pkg' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/namespace/alias2related',
+ '@stdlib/namespace/aliases',
+ '@stdlib/namespace/pkg2alias'
+ ]
+});
+
+ns.push({
+ 'alias': 'alias2related',
+ 'path': '@stdlib/namespace/alias2related',
+ 'value': require( '@stdlib/namespace/alias2related' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/namespace/alias2pkg',
+ '@stdlib/namespace/aliases',
+ '@stdlib/namespace/pkg2related'
+ ]
+});
+
+ns.push({
+ 'alias': 'aliases',
+ 'path': '@stdlib/namespace/aliases',
+ 'value': require( '@stdlib/namespace/aliases' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/namespace/alias2pkg',
+ '@stdlib/namespace/alias2related',
+ '@stdlib/namespace/pkg2alias'
+ ]
+});
+
ns.push({
'alias': 'allocUnsafe',
'path': '@stdlib/buffer/alloc-unsafe',
diff --git a/lib/node_modules/@stdlib/namespace/lib/namespace/d.js b/lib/node_modules/@stdlib/namespace/lib/namespace/d.js
index 97edc0ff06bd..383cbc61ae46 100644
--- a/lib/node_modules/@stdlib/namespace/lib/namespace/d.js
+++ b/lib/node_modules/@stdlib/namespace/lib/namespace/d.js
@@ -174,6 +174,17 @@ ns.push({
]
});
+ns.push({
+ 'alias': 'defineMemoizedProperty',
+ 'path': '@stdlib/utils/define-memoized-property',
+ 'value': require( '@stdlib/utils/define-memoized-property' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-memoized-read-only-property',
+ '@stdlib/utils/define-property'
+ ]
+});
+
ns.push({
'alias': 'defineProperties',
'path': '@stdlib/utils/define-properties',
diff --git a/lib/node_modules/@stdlib/namespace/lib/namespace/p.js b/lib/node_modules/@stdlib/namespace/lib/namespace/p.js
index e740126fd5a0..55903f5c2d85 100644
--- a/lib/node_modules/@stdlib/namespace/lib/namespace/p.js
+++ b/lib/node_modules/@stdlib/namespace/lib/namespace/p.js
@@ -224,6 +224,30 @@ ns.push({
]
});
+ns.push({
+ 'alias': 'pkg2alias',
+ 'path': '@stdlib/namespace/pkg2alias',
+ 'value': require( '@stdlib/namespace/pkg2alias' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/namespace/alias2pkg',
+ '@stdlib/namespace/aliases',
+ '@stdlib/namespace/pkg2related'
+ ]
+});
+
+ns.push({
+ 'alias': 'pkg2related',
+ 'path': '@stdlib/namespace/pkg2related',
+ 'value': require( '@stdlib/namespace/pkg2related' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/namespace/alias2related',
+ '@stdlib/namespace/aliases',
+ '@stdlib/namespace/pkg2alias'
+ ]
+});
+
ns.push({
'alias': 'PLATFORM',
'path': '@stdlib/os/platform',
diff --git a/lib/node_modules/@stdlib/namespace/lib/namespace/s.js b/lib/node_modules/@stdlib/namespace/lib/namespace/s.js
index cd5ace0ec45b..4f0e467bfcdc 100644
--- a/lib/node_modules/@stdlib/namespace/lib/namespace/s.js
+++ b/lib/node_modules/@stdlib/namespace/lib/namespace/s.js
@@ -166,6 +166,72 @@ ns.push({
]
});
+ns.push({
+ 'alias': 'setConfigurableReadOnly',
+ 'path': '@stdlib/utils/define-configurable-read-only-property',
+ 'value': require( '@stdlib/utils/define-configurable-read-only-property' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-configurable-read-only-accessor',
+ '@stdlib/utils/define-configurable-read-write-accessor',
+ '@stdlib/utils/define-property',
+ '@stdlib/utils/define-read-only-property'
+ ]
+});
+
+ns.push({
+ 'alias': 'setConfigurableReadOnlyAccessor',
+ 'path': '@stdlib/utils/define-configurable-read-only-accessor',
+ 'value': require( '@stdlib/utils/define-configurable-read-only-accessor' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-configurable-read-only-property',
+ '@stdlib/utils/define-configurable-read-write-accessor',
+ '@stdlib/utils/define-configurable-write-only-accessor',
+ '@stdlib/utils/define-property',
+ '@stdlib/utils/define-read-only-accessor'
+ ]
+});
+
+ns.push({
+ 'alias': 'setConfigurableReadWriteAccessor',
+ 'path': '@stdlib/utils/define-configurable-read-write-accessor',
+ 'value': require( '@stdlib/utils/define-configurable-read-write-accessor' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-configurable-read-only-property',
+ '@stdlib/utils/define-configurable-read-only-accessor',
+ '@stdlib/utils/define-configurable-write-only-accessor',
+ '@stdlib/utils/define-property',
+ '@stdlib/utils/define-read-write-accessor'
+ ]
+});
+
+ns.push({
+ 'alias': 'setConfigurableWriteOnlyAccessor',
+ 'path': '@stdlib/utils/define-configurable-write-only-accessor',
+ 'value': require( '@stdlib/utils/define-configurable-write-only-accessor' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-configurable-read-only-property',
+ '@stdlib/utils/define-configurable-read-only-accessor',
+ '@stdlib/utils/define-configurable-read-write-accessor',
+ '@stdlib/utils/define-property',
+ '@stdlib/utils/define-write-only-accessor'
+ ]
+});
+
+ns.push({
+ 'alias': 'setMemoizedReadOnly',
+ 'path': '@stdlib/utils/define-memoized-read-only-property',
+ 'value': require( '@stdlib/utils/define-memoized-read-only-property' ),
+ 'type': 'Function',
+ 'related': [
+ '@stdlib/utils/define-memoized-property',
+ '@stdlib/utils/define-read-only-property'
+ ]
+});
+
ns.push({
'alias': 'setNonEnumerableProperty',
'path': '@stdlib/utils/define-nonenumerable-property',
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/LICENSE b/lib/node_modules/@stdlib/namespace/pkg2alias/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/README.md b/lib/node_modules/@stdlib/namespace/pkg2alias/README.md
new file mode 100644
index 000000000000..f4762cf27c59
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/README.md
@@ -0,0 +1,193 @@
+
+
+# pkg2alias
+
+> Return the alias associated with a specified package name.
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var pkg2alias = require( '@stdlib/namespace/pkg2alias' );
+```
+
+#### pkg2alias( pkg )
+
+Returns the alias associated with a specified package name.
+
+```javascript
+var v = pkg2alias( '@stdlib/math/base/special/sin' );
+// returns 'base.sin'
+```
+
+If provided an unrecognized `pkg`, the function returns `null`.
+
+```javascript
+var v = pkg2alias( 'unrecognized_pkg_beep_boop_bop_bip' );
+// returns null
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var pkg2alias = require( '@stdlib/namespace/pkg2alias' );
+
+var list;
+var len;
+var idx;
+var v1;
+var v2;
+var i;
+
+list = aliases();
+len = list.length;
+
+// Round-trip from alias-to-pkg-to-alias...
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v1 = alias2pkg( list[ idx ] );
+ v2 = pkg2alias( v1 );
+ console.log( 'alias: %s. pkg: %s.', list[ idx ], v1 );
+ console.log( 'pkg: %s. alias: %s.', v1, v2 );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-pkg2alias [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-pkg2alias '@stdlib/math/base/special/sin'
+base.sin
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/benchmark/benchmark.js b/lib/node_modules/@stdlib/namespace/pkg2alias/benchmark/benchmark.js
new file mode 100644
index 000000000000..f22004454776
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/benchmark/benchmark.js
@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var pkg = require( './../package.json' ).name;
+var pkg2alias = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '@stdlib/math/base/special/sin',
+ '@stdlib/math/base/special/abs',
+ '@stdlib/math/base/special/cos'
+ ];
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = pkg2alias( values[ i%values.length ] );
+ if ( typeof v !== 'string' ) {
+ b.fail( 'should return a string' );
+ }
+ }
+ b.toc();
+ if ( !isString( v ) ) {
+ b.fail( 'should return a string' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/bin/cli b/lib/node_modules/@stdlib/namespace/pkg2alias/bin/cli
new file mode 100755
index 000000000000..568fbb91b442
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/bin/cli
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var pkg2alias = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Resolve a provided package name to an alias...
+ out = pkg2alias( args[ 0 ] );
+ if ( out ) {
+ console.log( out ); // eslint-disable-line no-console
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv
new file mode 100644
index 000000000000..b045f5ac7f4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.csv
@@ -0,0 +1,1894 @@
+"@stdlib/datasets/afinn-96",AFINN_96
+"@stdlib/datasets/afinn-111",AFINN_111
+"@stdlib/namespace/alias2pkg",alias2pkg
+"@stdlib/namespace/alias2related",alias2related
+"@stdlib/namespace/aliases",aliases
+"@stdlib/buffer/alloc-unsafe",allocUnsafe
+"@stdlib/stats/anova1",anova1
+"@stdlib/datasets/anscombes-quartet",ANSCOMBES_QUARTET
+"@stdlib/utils/any",any
+"@stdlib/utils/any-by",anyBy
+"@stdlib/utils/async/any-by",anyByAsync
+"@stdlib/utils/any-by-right",anyByRight
+"@stdlib/utils/async/any-by-right",anyByRightAsync
+"@stdlib/constants/math/float64-apery",APERY
+"@stdlib/utils/append",append
+"@stdlib/os/arch",ARCH
+"@stdlib/utils/argument-function",argumentFunction
+"@stdlib/process/argv",ARGV
+"@stdlib/ndarray/array",array
+"@stdlib/buffer/from-array",array2buffer
+"@stdlib/array/to-iterator",array2iterator
+"@stdlib/array/to-iterator-right",array2iteratorRight
+"@stdlib/array/buffer",ArrayBuffer
+"@stdlib/buffer/from-arraybuffer",arraybuffer2buffer
+"@stdlib/array/ctors",arrayCtors
+"@stdlib/array/dtype",arrayDataType
+"@stdlib/array/dtypes",arrayDataTypes
+"@stdlib/array/min-dtype",arrayMinDataType
+"@stdlib/array/next-dtype",arrayNextDataType
+"@stdlib/array/promotion-rules",arrayPromotionRules
+"@stdlib/array/safe-casts",arraySafeCasts
+"@stdlib/array/same-kind-casts",arraySameKindCasts
+"@stdlib/array/shape",arrayShape
+"@stdlib/streams/node/from-array",arrayStream
+"@stdlib/array/to-view-iterator",arrayview2iterator
+"@stdlib/array/to-view-iterator-right",arrayview2iteratorRight
+"@stdlib/symbol/async-iterator",AsyncIteratorSymbol
+"@stdlib/stats/bartlett-test",bartlettTest
+"@stdlib/math/base/special/abs",base.abs
+"@stdlib/math/base/special/abs2",base.abs2
+"@stdlib/math/base/utils/absolute-difference",base.absdiff
+"@stdlib/math/base/special/int32-abs",base.absInt32
+"@stdlib/math/base/special/acos",base.acos
+"@stdlib/math/base/special/acosh",base.acosh
+"@stdlib/math/base/special/acoth",base.acoth
+"@stdlib/math/base/special/acovercos",base.acovercos
+"@stdlib/math/base/special/acoversin",base.acoversin
+"@stdlib/math/base/special/ahavercos",base.ahavercos
+"@stdlib/math/base/special/ahaversin",base.ahaversin
+"@stdlib/math/base/special/asin",base.asin
+"@stdlib/math/base/special/asinh",base.asinh
+"@stdlib/math/base/special/atan",base.atan
+"@stdlib/math/base/special/atan2",base.atan2
+"@stdlib/math/base/special/atanh",base.atanh
+"@stdlib/math/base/special/avercos",base.avercos
+"@stdlib/math/base/special/aversin",base.aversin
+"@stdlib/math/base/special/bernoulli",base.bernoulli
+"@stdlib/math/base/special/besselj0",base.besselj0
+"@stdlib/math/base/special/besselj1",base.besselj1
+"@stdlib/math/base/special/bessely0",base.bessely0
+"@stdlib/math/base/special/bessely1",base.bessely1
+"@stdlib/math/base/special/beta",base.beta
+"@stdlib/math/base/special/betainc",base.betainc
+"@stdlib/math/base/special/betaincinv",base.betaincinv
+"@stdlib/math/base/special/betaln",base.betaln
+"@stdlib/math/base/special/binet",base.binet
+"@stdlib/math/base/special/binomcoef",base.binomcoef
+"@stdlib/math/base/special/binomcoefln",base.binomcoefln
+"@stdlib/math/base/special/boxcox",base.boxcox
+"@stdlib/math/base/special/boxcox1p",base.boxcox1p
+"@stdlib/math/base/special/boxcox1pinv",base.boxcox1pinv
+"@stdlib/math/base/special/boxcoxinv",base.boxcoxinv
+"@stdlib/math/base/complex/abs",base.cabs
+"@stdlib/math/base/complex/abs2",base.cabs2
+"@stdlib/math/base/complex/add",base.cadd
+"@stdlib/math/base/special/cbrt",base.cbrt
+"@stdlib/math/base/complex/ceil",base.cceil
+"@stdlib/math/base/complex/ceiln",base.cceiln
+"@stdlib/math/base/complex/cis",base.ccis
+"@stdlib/math/base/complex/divide",base.cdiv
+"@stdlib/math/base/special/ceil",base.ceil
+"@stdlib/math/base/special/ceil2",base.ceil2
+"@stdlib/math/base/special/ceil10",base.ceil10
+"@stdlib/math/base/special/ceilb",base.ceilb
+"@stdlib/math/base/special/ceiln",base.ceiln
+"@stdlib/math/base/special/ceilsd",base.ceilsd
+"@stdlib/math/base/complex/exp",base.cexp
+"@stdlib/math/base/complex/flipsign",base.cflipsign
+"@stdlib/math/base/complex/floor",base.cfloor
+"@stdlib/math/base/complex/floorn",base.cfloorn
+"@stdlib/math/base/complex/inv",base.cinv
+"@stdlib/math/base/special/clamp",base.clamp
+"@stdlib/math/base/complex/multiply",base.cmul
+"@stdlib/math/base/complex/negate",base.cneg
+"@stdlib/math/base/tools/continued-fraction",base.continuedFraction
+"@stdlib/math/base/special/copysign",base.copysign
+"@stdlib/math/base/special/cos",base.cos
+"@stdlib/math/base/special/cosh",base.cosh
+"@stdlib/math/base/special/cosm1",base.cosm1
+"@stdlib/math/base/special/cospi",base.cospi
+"@stdlib/math/base/special/covercos",base.covercos
+"@stdlib/math/base/special/coversin",base.coversin
+"@stdlib/math/base/complex/phase",base.cphase
+"@stdlib/math/base/complex/polar",base.cpolar
+"@stdlib/math/base/complex/round",base.cround
+"@stdlib/math/base/complex/roundn",base.croundn
+"@stdlib/math/base/complex/signum",base.csignum
+"@stdlib/math/base/complex/subtract",base.csub
+"@stdlib/blas/base/dasum",base.dasum
+"@stdlib/blas/base/daxpy",base.daxpy
+"@stdlib/blas/base/dcopy",base.dcopy
+"@stdlib/math/base/special/deg2rad",base.deg2rad
+"@stdlib/math/base/special/digamma",base.digamma
+"@stdlib/math/base/special/dirac-delta",base.diracDelta
+"@stdlib/stats/base/dists/arcsine/ctor",base.dists.arcsine.Arcsine
+"@stdlib/stats/base/dists/arcsine/cdf",base.dists.arcsine.cdf
+"@stdlib/stats/base/dists/arcsine/entropy",base.dists.arcsine.entropy
+"@stdlib/stats/base/dists/arcsine/kurtosis",base.dists.arcsine.kurtosis
+"@stdlib/stats/base/dists/arcsine/logcdf",base.dists.arcsine.logcdf
+"@stdlib/stats/base/dists/arcsine/logpdf",base.dists.arcsine.logpdf
+"@stdlib/stats/base/dists/arcsine/mean",base.dists.arcsine.mean
+"@stdlib/stats/base/dists/arcsine/median",base.dists.arcsine.median
+"@stdlib/stats/base/dists/arcsine/mode",base.dists.arcsine.mode
+"@stdlib/stats/base/dists/arcsine/pdf",base.dists.arcsine.pdf
+"@stdlib/stats/base/dists/arcsine/quantile",base.dists.arcsine.quantile
+"@stdlib/stats/base/dists/arcsine/skewness",base.dists.arcsine.skewness
+"@stdlib/stats/base/dists/arcsine/stdev",base.dists.arcsine.stdev
+"@stdlib/stats/base/dists/arcsine/variance",base.dists.arcsine.variance
+"@stdlib/stats/base/dists/bernoulli/ctor",base.dists.bernoulli.Bernoulli
+"@stdlib/stats/base/dists/bernoulli/cdf",base.dists.bernoulli.cdf
+"@stdlib/stats/base/dists/bernoulli/entropy",base.dists.bernoulli.entropy
+"@stdlib/stats/base/dists/bernoulli/kurtosis",base.dists.bernoulli.kurtosis
+"@stdlib/stats/base/dists/bernoulli/mean",base.dists.bernoulli.mean
+"@stdlib/stats/base/dists/bernoulli/median",base.dists.bernoulli.median
+"@stdlib/stats/base/dists/bernoulli/mgf",base.dists.bernoulli.mgf
+"@stdlib/stats/base/dists/bernoulli/mode",base.dists.bernoulli.mode
+"@stdlib/stats/base/dists/bernoulli/pmf",base.dists.bernoulli.pmf
+"@stdlib/stats/base/dists/bernoulli/quantile",base.dists.bernoulli.quantile
+"@stdlib/stats/base/dists/bernoulli/skewness",base.dists.bernoulli.skewness
+"@stdlib/stats/base/dists/bernoulli/stdev",base.dists.bernoulli.stdev
+"@stdlib/stats/base/dists/bernoulli/variance",base.dists.bernoulli.variance
+"@stdlib/stats/base/dists/beta/ctor",base.dists.beta.Beta
+"@stdlib/stats/base/dists/beta/cdf",base.dists.beta.cdf
+"@stdlib/stats/base/dists/beta/entropy",base.dists.beta.entropy
+"@stdlib/stats/base/dists/beta/kurtosis",base.dists.beta.kurtosis
+"@stdlib/stats/base/dists/beta/logcdf",base.dists.beta.logcdf
+"@stdlib/stats/base/dists/beta/logpdf",base.dists.beta.logpdf
+"@stdlib/stats/base/dists/beta/mean",base.dists.beta.mean
+"@stdlib/stats/base/dists/beta/median",base.dists.beta.median
+"@stdlib/stats/base/dists/beta/mgf",base.dists.beta.mgf
+"@stdlib/stats/base/dists/beta/mode",base.dists.beta.mode
+"@stdlib/stats/base/dists/beta/pdf",base.dists.beta.pdf
+"@stdlib/stats/base/dists/beta/quantile",base.dists.beta.quantile
+"@stdlib/stats/base/dists/beta/skewness",base.dists.beta.skewness
+"@stdlib/stats/base/dists/beta/stdev",base.dists.beta.stdev
+"@stdlib/stats/base/dists/beta/variance",base.dists.beta.variance
+"@stdlib/stats/base/dists/betaprime/ctor",base.dists.betaprime.BetaPrime
+"@stdlib/stats/base/dists/betaprime/cdf",base.dists.betaprime.cdf
+"@stdlib/stats/base/dists/betaprime/kurtosis",base.dists.betaprime.kurtosis
+"@stdlib/stats/base/dists/betaprime/logcdf",base.dists.betaprime.logcdf
+"@stdlib/stats/base/dists/betaprime/logpdf",base.dists.betaprime.logpdf
+"@stdlib/stats/base/dists/betaprime/mean",base.dists.betaprime.mean
+"@stdlib/stats/base/dists/betaprime/mode",base.dists.betaprime.mode
+"@stdlib/stats/base/dists/betaprime/pdf",base.dists.betaprime.pdf
+"@stdlib/stats/base/dists/betaprime/quantile",base.dists.betaprime.quantile
+"@stdlib/stats/base/dists/betaprime/skewness",base.dists.betaprime.skewness
+"@stdlib/stats/base/dists/betaprime/stdev",base.dists.betaprime.stdev
+"@stdlib/stats/base/dists/betaprime/variance",base.dists.betaprime.variance
+"@stdlib/stats/base/dists/binomial/ctor",base.dists.binomial.Binomial
+"@stdlib/stats/base/dists/binomial/cdf",base.dists.binomial.cdf
+"@stdlib/stats/base/dists/binomial/entropy",base.dists.binomial.entropy
+"@stdlib/stats/base/dists/binomial/kurtosis",base.dists.binomial.kurtosis
+"@stdlib/stats/base/dists/binomial/logpmf",base.dists.binomial.logpmf
+"@stdlib/stats/base/dists/binomial/mean",base.dists.binomial.mean
+"@stdlib/stats/base/dists/binomial/median",base.dists.binomial.median
+"@stdlib/stats/base/dists/binomial/mgf",base.dists.binomial.mgf
+"@stdlib/stats/base/dists/binomial/mode",base.dists.binomial.mode
+"@stdlib/stats/base/dists/binomial/pmf",base.dists.binomial.pmf
+"@stdlib/stats/base/dists/binomial/quantile",base.dists.binomial.quantile
+"@stdlib/stats/base/dists/binomial/skewness",base.dists.binomial.skewness
+"@stdlib/stats/base/dists/binomial/stdev",base.dists.binomial.stdev
+"@stdlib/stats/base/dists/binomial/variance",base.dists.binomial.variance
+"@stdlib/stats/base/dists/cauchy/ctor",base.dists.cauchy.Cauchy
+"@stdlib/stats/base/dists/cauchy/cdf",base.dists.cauchy.cdf
+"@stdlib/stats/base/dists/cauchy/entropy",base.dists.cauchy.entropy
+"@stdlib/stats/base/dists/cauchy/logcdf",base.dists.cauchy.logcdf
+"@stdlib/stats/base/dists/cauchy/logpdf",base.dists.cauchy.logpdf
+"@stdlib/stats/base/dists/cauchy/median",base.dists.cauchy.median
+"@stdlib/stats/base/dists/cauchy/mode",base.dists.cauchy.mode
+"@stdlib/stats/base/dists/cauchy/pdf",base.dists.cauchy.pdf
+"@stdlib/stats/base/dists/cauchy/quantile",base.dists.cauchy.quantile
+"@stdlib/stats/base/dists/chi/cdf",base.dists.chi.cdf
+"@stdlib/stats/base/dists/chi/ctor",base.dists.chi.Chi
+"@stdlib/stats/base/dists/chi/entropy",base.dists.chi.entropy
+"@stdlib/stats/base/dists/chi/kurtosis",base.dists.chi.kurtosis
+"@stdlib/stats/base/dists/chi/logpdf",base.dists.chi.logpdf
+"@stdlib/stats/base/dists/chi/mean",base.dists.chi.mean
+"@stdlib/stats/base/dists/chi/mode",base.dists.chi.mode
+"@stdlib/stats/base/dists/chi/pdf",base.dists.chi.pdf
+"@stdlib/stats/base/dists/chi/quantile",base.dists.chi.quantile
+"@stdlib/stats/base/dists/chi/skewness",base.dists.chi.skewness
+"@stdlib/stats/base/dists/chi/stdev",base.dists.chi.stdev
+"@stdlib/stats/base/dists/chi/variance",base.dists.chi.variance
+"@stdlib/stats/base/dists/chisquare/cdf",base.dists.chisquare.cdf
+"@stdlib/stats/base/dists/chisquare/ctor",base.dists.chisquare.ChiSquare
+"@stdlib/stats/base/dists/chisquare/entropy",base.dists.chisquare.entropy
+"@stdlib/stats/base/dists/chisquare/kurtosis",base.dists.chisquare.kurtosis
+"@stdlib/stats/base/dists/chisquare/logpdf",base.dists.chisquare.logpdf
+"@stdlib/stats/base/dists/chisquare/mean",base.dists.chisquare.mean
+"@stdlib/stats/base/dists/chisquare/mgf",base.dists.chisquare.mgf
+"@stdlib/stats/base/dists/chisquare/mode",base.dists.chisquare.mode
+"@stdlib/stats/base/dists/chisquare/pdf",base.dists.chisquare.pdf
+"@stdlib/stats/base/dists/chisquare/quantile",base.dists.chisquare.quantile
+"@stdlib/stats/base/dists/chisquare/skewness",base.dists.chisquare.skewness
+"@stdlib/stats/base/dists/chisquare/stdev",base.dists.chisquare.stdev
+"@stdlib/stats/base/dists/chisquare/variance",base.dists.chisquare.variance
+"@stdlib/stats/base/dists/cosine/cdf",base.dists.cosine.cdf
+"@stdlib/stats/base/dists/cosine/ctor",base.dists.cosine.Cosine
+"@stdlib/stats/base/dists/cosine/kurtosis",base.dists.cosine.kurtosis
+"@stdlib/stats/base/dists/cosine/logcdf",base.dists.cosine.logcdf
+"@stdlib/stats/base/dists/cosine/logpdf",base.dists.cosine.logpdf
+"@stdlib/stats/base/dists/cosine/mean",base.dists.cosine.mean
+"@stdlib/stats/base/dists/cosine/median",base.dists.cosine.median
+"@stdlib/stats/base/dists/cosine/mgf",base.dists.cosine.mgf
+"@stdlib/stats/base/dists/cosine/mode",base.dists.cosine.mode
+"@stdlib/stats/base/dists/cosine/pdf",base.dists.cosine.pdf
+"@stdlib/stats/base/dists/cosine/quantile",base.dists.cosine.quantile
+"@stdlib/stats/base/dists/cosine/skewness",base.dists.cosine.skewness
+"@stdlib/stats/base/dists/cosine/stdev",base.dists.cosine.stdev
+"@stdlib/stats/base/dists/cosine/variance",base.dists.cosine.variance
+"@stdlib/stats/base/dists/degenerate/cdf",base.dists.degenerate.cdf
+"@stdlib/stats/base/dists/degenerate/ctor",base.dists.degenerate.Degenerate
+"@stdlib/stats/base/dists/degenerate/entropy",base.dists.degenerate.entropy
+"@stdlib/stats/base/dists/degenerate/logcdf",base.dists.degenerate.logcdf
+"@stdlib/stats/base/dists/degenerate/logpdf",base.dists.degenerate.logpdf
+"@stdlib/stats/base/dists/degenerate/logpmf",base.dists.degenerate.logpmf
+"@stdlib/stats/base/dists/degenerate/mean",base.dists.degenerate.mean
+"@stdlib/stats/base/dists/degenerate/median",base.dists.degenerate.median
+"@stdlib/stats/base/dists/degenerate/mgf",base.dists.degenerate.mgf
+"@stdlib/stats/base/dists/degenerate/mode",base.dists.degenerate.mode
+"@stdlib/stats/base/dists/degenerate/pdf",base.dists.degenerate.pdf
+"@stdlib/stats/base/dists/degenerate/pmf",base.dists.degenerate.pmf
+"@stdlib/stats/base/dists/degenerate/quantile",base.dists.degenerate.quantile
+"@stdlib/stats/base/dists/degenerate/stdev",base.dists.degenerate.stdev
+"@stdlib/stats/base/dists/degenerate/variance",base.dists.degenerate.variance
+"@stdlib/stats/base/dists/discrete-uniform/cdf",base.dists.discreteUniform.cdf
+"@stdlib/stats/base/dists/discrete-uniform/ctor",base.dists.discreteUniform.DiscreteUniform
+"@stdlib/stats/base/dists/discrete-uniform/kurtosis",base.dists.discreteUniform.kurtosis
+"@stdlib/stats/base/dists/discrete-uniform/logcdf",base.dists.discreteUniform.logcdf
+"@stdlib/stats/base/dists/discrete-uniform/logpmf",base.dists.discreteUniform.logpmf
+"@stdlib/stats/base/dists/discrete-uniform/mean",base.dists.discreteUniform.mean
+"@stdlib/stats/base/dists/discrete-uniform/median",base.dists.discreteUniform.median
+"@stdlib/stats/base/dists/discrete-uniform/mgf",base.dists.discreteUniform.mgf
+"@stdlib/stats/base/dists/discrete-uniform/pmf",base.dists.discreteUniform.pmf
+"@stdlib/stats/base/dists/discrete-uniform/quantile",base.dists.discreteUniform.quantile
+"@stdlib/stats/base/dists/discrete-uniform/skewness",base.dists.discreteUniform.skewness
+"@stdlib/stats/base/dists/discrete-uniform/stdev",base.dists.discreteUniform.stdev
+"@stdlib/stats/base/dists/discrete-uniform/variance",base.dists.discreteUniform.variance
+"@stdlib/stats/base/dists/erlang/cdf",base.dists.erlang.cdf
+"@stdlib/stats/base/dists/erlang/entropy",base.dists.erlang.entropy
+"@stdlib/stats/base/dists/erlang/ctor",base.dists.erlang.Erlang
+"@stdlib/stats/base/dists/erlang/kurtosis",base.dists.erlang.kurtosis
+"@stdlib/stats/base/dists/erlang/logpdf",base.dists.erlang.logpdf
+"@stdlib/stats/base/dists/erlang/mean",base.dists.erlang.mean
+"@stdlib/stats/base/dists/erlang/mgf",base.dists.erlang.mgf
+"@stdlib/stats/base/dists/erlang/mode",base.dists.erlang.mode
+"@stdlib/stats/base/dists/erlang/pdf",base.dists.erlang.pdf
+"@stdlib/stats/base/dists/erlang/quantile",base.dists.erlang.quantile
+"@stdlib/stats/base/dists/erlang/skewness",base.dists.erlang.skewness
+"@stdlib/stats/base/dists/erlang/stdev",base.dists.erlang.stdev
+"@stdlib/stats/base/dists/erlang/variance",base.dists.erlang.variance
+"@stdlib/stats/base/dists/exponential/cdf",base.dists.exponential.cdf
+"@stdlib/stats/base/dists/exponential/entropy",base.dists.exponential.entropy
+"@stdlib/stats/base/dists/exponential/ctor",base.dists.exponential.Exponential
+"@stdlib/stats/base/dists/exponential/kurtosis",base.dists.exponential.kurtosis
+"@stdlib/stats/base/dists/exponential/logcdf",base.dists.exponential.logcdf
+"@stdlib/stats/base/dists/exponential/logpdf",base.dists.exponential.logpdf
+"@stdlib/stats/base/dists/exponential/mean",base.dists.exponential.mean
+"@stdlib/stats/base/dists/exponential/median",base.dists.exponential.median
+"@stdlib/stats/base/dists/exponential/mgf",base.dists.exponential.mgf
+"@stdlib/stats/base/dists/exponential/mode",base.dists.exponential.mode
+"@stdlib/stats/base/dists/exponential/pdf",base.dists.exponential.pdf
+"@stdlib/stats/base/dists/exponential/quantile",base.dists.exponential.quantile
+"@stdlib/stats/base/dists/exponential/skewness",base.dists.exponential.skewness
+"@stdlib/stats/base/dists/exponential/stdev",base.dists.exponential.stdev
+"@stdlib/stats/base/dists/exponential/variance",base.dists.exponential.variance
+"@stdlib/stats/base/dists/f/cdf",base.dists.f.cdf
+"@stdlib/stats/base/dists/f/entropy",base.dists.f.entropy
+"@stdlib/stats/base/dists/f/ctor",base.dists.f.F
+"@stdlib/stats/base/dists/f/kurtosis",base.dists.f.kurtosis
+"@stdlib/stats/base/dists/f/mean",base.dists.f.mean
+"@stdlib/stats/base/dists/f/mode",base.dists.f.mode
+"@stdlib/stats/base/dists/f/pdf",base.dists.f.pdf
+"@stdlib/stats/base/dists/f/quantile",base.dists.f.quantile
+"@stdlib/stats/base/dists/f/skewness",base.dists.f.skewness
+"@stdlib/stats/base/dists/f/stdev",base.dists.f.stdev
+"@stdlib/stats/base/dists/f/variance",base.dists.f.variance
+"@stdlib/stats/base/dists/frechet/cdf",base.dists.frechet.cdf
+"@stdlib/stats/base/dists/frechet/entropy",base.dists.frechet.entropy
+"@stdlib/stats/base/dists/frechet/ctor",base.dists.frechet.Frechet
+"@stdlib/stats/base/dists/frechet/kurtosis",base.dists.frechet.kurtosis
+"@stdlib/stats/base/dists/frechet/logcdf",base.dists.frechet.logcdf
+"@stdlib/stats/base/dists/frechet/logpdf",base.dists.frechet.logpdf
+"@stdlib/stats/base/dists/frechet/mean",base.dists.frechet.mean
+"@stdlib/stats/base/dists/frechet/median",base.dists.frechet.median
+"@stdlib/stats/base/dists/frechet/mode",base.dists.frechet.mode
+"@stdlib/stats/base/dists/frechet/pdf",base.dists.frechet.pdf
+"@stdlib/stats/base/dists/frechet/quantile",base.dists.frechet.quantile
+"@stdlib/stats/base/dists/frechet/skewness",base.dists.frechet.skewness
+"@stdlib/stats/base/dists/frechet/stdev",base.dists.frechet.stdev
+"@stdlib/stats/base/dists/frechet/variance",base.dists.frechet.variance
+"@stdlib/stats/base/dists/gamma/cdf",base.dists.gamma.cdf
+"@stdlib/stats/base/dists/gamma/entropy",base.dists.gamma.entropy
+"@stdlib/stats/base/dists/gamma/ctor",base.dists.gamma.Gamma
+"@stdlib/stats/base/dists/gamma/kurtosis",base.dists.gamma.kurtosis
+"@stdlib/stats/base/dists/gamma/logpdf",base.dists.gamma.logpdf
+"@stdlib/stats/base/dists/gamma/mean",base.dists.gamma.mean
+"@stdlib/stats/base/dists/gamma/mgf",base.dists.gamma.mgf
+"@stdlib/stats/base/dists/gamma/mode",base.dists.gamma.mode
+"@stdlib/stats/base/dists/gamma/pdf",base.dists.gamma.pdf
+"@stdlib/stats/base/dists/gamma/quantile",base.dists.gamma.quantile
+"@stdlib/stats/base/dists/gamma/skewness",base.dists.gamma.skewness
+"@stdlib/stats/base/dists/gamma/stdev",base.dists.gamma.stdev
+"@stdlib/stats/base/dists/gamma/variance",base.dists.gamma.variance
+"@stdlib/stats/base/dists/geometric/cdf",base.dists.geometric.cdf
+"@stdlib/stats/base/dists/geometric/entropy",base.dists.geometric.entropy
+"@stdlib/stats/base/dists/geometric/ctor",base.dists.geometric.Geometric
+"@stdlib/stats/base/dists/geometric/kurtosis",base.dists.geometric.kurtosis
+"@stdlib/stats/base/dists/geometric/logcdf",base.dists.geometric.logcdf
+"@stdlib/stats/base/dists/geometric/logpmf",base.dists.geometric.logpmf
+"@stdlib/stats/base/dists/geometric/mean",base.dists.geometric.mean
+"@stdlib/stats/base/dists/geometric/median",base.dists.geometric.median
+"@stdlib/stats/base/dists/geometric/mgf",base.dists.geometric.mgf
+"@stdlib/stats/base/dists/geometric/mode",base.dists.geometric.mode
+"@stdlib/stats/base/dists/geometric/pmf",base.dists.geometric.pmf
+"@stdlib/stats/base/dists/geometric/quantile",base.dists.geometric.quantile
+"@stdlib/stats/base/dists/geometric/skewness",base.dists.geometric.skewness
+"@stdlib/stats/base/dists/geometric/stdev",base.dists.geometric.stdev
+"@stdlib/stats/base/dists/geometric/variance",base.dists.geometric.variance
+"@stdlib/stats/base/dists/gumbel/cdf",base.dists.gumbel.cdf
+"@stdlib/stats/base/dists/gumbel/entropy",base.dists.gumbel.entropy
+"@stdlib/stats/base/dists/gumbel/ctor",base.dists.gumbel.Gumbel
+"@stdlib/stats/base/dists/gumbel/kurtosis",base.dists.gumbel.kurtosis
+"@stdlib/stats/base/dists/gumbel/logcdf",base.dists.gumbel.logcdf
+"@stdlib/stats/base/dists/gumbel/logpdf",base.dists.gumbel.logpdf
+"@stdlib/stats/base/dists/gumbel/mean",base.dists.gumbel.mean
+"@stdlib/stats/base/dists/gumbel/median",base.dists.gumbel.median
+"@stdlib/stats/base/dists/gumbel/mgf",base.dists.gumbel.mgf
+"@stdlib/stats/base/dists/gumbel/mode",base.dists.gumbel.mode
+"@stdlib/stats/base/dists/gumbel/pdf",base.dists.gumbel.pdf
+"@stdlib/stats/base/dists/gumbel/quantile",base.dists.gumbel.quantile
+"@stdlib/stats/base/dists/gumbel/skewness",base.dists.gumbel.skewness
+"@stdlib/stats/base/dists/gumbel/stdev",base.dists.gumbel.stdev
+"@stdlib/stats/base/dists/gumbel/variance",base.dists.gumbel.variance
+"@stdlib/stats/base/dists/hypergeometric/cdf",base.dists.hypergeometric.cdf
+"@stdlib/stats/base/dists/hypergeometric/ctor",base.dists.hypergeometric.Hypergeometric
+"@stdlib/stats/base/dists/hypergeometric/kurtosis",base.dists.hypergeometric.kurtosis
+"@stdlib/stats/base/dists/hypergeometric/logpmf",base.dists.hypergeometric.logpmf
+"@stdlib/stats/base/dists/hypergeometric/mean",base.dists.hypergeometric.mean
+"@stdlib/stats/base/dists/hypergeometric/mode",base.dists.hypergeometric.mode
+"@stdlib/stats/base/dists/hypergeometric/pmf",base.dists.hypergeometric.pmf
+"@stdlib/stats/base/dists/hypergeometric/quantile",base.dists.hypergeometric.quantile
+"@stdlib/stats/base/dists/hypergeometric/skewness",base.dists.hypergeometric.skewness
+"@stdlib/stats/base/dists/hypergeometric/stdev",base.dists.hypergeometric.stdev
+"@stdlib/stats/base/dists/hypergeometric/variance",base.dists.hypergeometric.variance
+"@stdlib/stats/base/dists/invgamma/cdf",base.dists.invgamma.cdf
+"@stdlib/stats/base/dists/invgamma/entropy",base.dists.invgamma.entropy
+"@stdlib/stats/base/dists/invgamma/ctor",base.dists.invgamma.InvGamma
+"@stdlib/stats/base/dists/invgamma/kurtosis",base.dists.invgamma.kurtosis
+"@stdlib/stats/base/dists/invgamma/logpdf",base.dists.invgamma.logpdf
+"@stdlib/stats/base/dists/invgamma/mean",base.dists.invgamma.mean
+"@stdlib/stats/base/dists/invgamma/mode",base.dists.invgamma.mode
+"@stdlib/stats/base/dists/invgamma/pdf",base.dists.invgamma.pdf
+"@stdlib/stats/base/dists/invgamma/quantile",base.dists.invgamma.quantile
+"@stdlib/stats/base/dists/invgamma/skewness",base.dists.invgamma.skewness
+"@stdlib/stats/base/dists/invgamma/stdev",base.dists.invgamma.stdev
+"@stdlib/stats/base/dists/invgamma/variance",base.dists.invgamma.variance
+"@stdlib/stats/base/dists/kumaraswamy/cdf",base.dists.kumaraswamy.cdf
+"@stdlib/stats/base/dists/kumaraswamy/ctor",base.dists.kumaraswamy.Kumaraswamy
+"@stdlib/stats/base/dists/kumaraswamy/kurtosis",base.dists.kumaraswamy.kurtosis
+"@stdlib/stats/base/dists/kumaraswamy/logcdf",base.dists.kumaraswamy.logcdf
+"@stdlib/stats/base/dists/kumaraswamy/logpdf",base.dists.kumaraswamy.logpdf
+"@stdlib/stats/base/dists/kumaraswamy/mean",base.dists.kumaraswamy.mean
+"@stdlib/stats/base/dists/kumaraswamy/median",base.dists.kumaraswamy.median
+"@stdlib/stats/base/dists/kumaraswamy/mode",base.dists.kumaraswamy.mode
+"@stdlib/stats/base/dists/kumaraswamy/pdf",base.dists.kumaraswamy.pdf
+"@stdlib/stats/base/dists/kumaraswamy/quantile",base.dists.kumaraswamy.quantile
+"@stdlib/stats/base/dists/kumaraswamy/skewness",base.dists.kumaraswamy.skewness
+"@stdlib/stats/base/dists/kumaraswamy/stdev",base.dists.kumaraswamy.stdev
+"@stdlib/stats/base/dists/kumaraswamy/variance",base.dists.kumaraswamy.variance
+"@stdlib/stats/base/dists/laplace/cdf",base.dists.laplace.cdf
+"@stdlib/stats/base/dists/laplace/entropy",base.dists.laplace.entropy
+"@stdlib/stats/base/dists/laplace/kurtosis",base.dists.laplace.kurtosis
+"@stdlib/stats/base/dists/laplace/ctor",base.dists.laplace.Laplace
+"@stdlib/stats/base/dists/laplace/logcdf",base.dists.laplace.logcdf
+"@stdlib/stats/base/dists/laplace/logpdf",base.dists.laplace.logpdf
+"@stdlib/stats/base/dists/laplace/mean",base.dists.laplace.mean
+"@stdlib/stats/base/dists/laplace/median",base.dists.laplace.median
+"@stdlib/stats/base/dists/laplace/mgf",base.dists.laplace.mgf
+"@stdlib/stats/base/dists/laplace/mode",base.dists.laplace.mode
+"@stdlib/stats/base/dists/laplace/pdf",base.dists.laplace.pdf
+"@stdlib/stats/base/dists/laplace/quantile",base.dists.laplace.quantile
+"@stdlib/stats/base/dists/laplace/skewness",base.dists.laplace.skewness
+"@stdlib/stats/base/dists/laplace/stdev",base.dists.laplace.stdev
+"@stdlib/stats/base/dists/laplace/variance",base.dists.laplace.variance
+"@stdlib/stats/base/dists/levy/cdf",base.dists.levy.cdf
+"@stdlib/stats/base/dists/levy/entropy",base.dists.levy.entropy
+"@stdlib/stats/base/dists/levy/ctor",base.dists.levy.Levy
+"@stdlib/stats/base/dists/levy/logcdf",base.dists.levy.logcdf
+"@stdlib/stats/base/dists/levy/logpdf",base.dists.levy.logpdf
+"@stdlib/stats/base/dists/levy/mean",base.dists.levy.mean
+"@stdlib/stats/base/dists/levy/median",base.dists.levy.median
+"@stdlib/stats/base/dists/levy/mode",base.dists.levy.mode
+"@stdlib/stats/base/dists/levy/pdf",base.dists.levy.pdf
+"@stdlib/stats/base/dists/levy/quantile",base.dists.levy.quantile
+"@stdlib/stats/base/dists/levy/stdev",base.dists.levy.stdev
+"@stdlib/stats/base/dists/levy/variance",base.dists.levy.variance
+"@stdlib/stats/base/dists/logistic/cdf",base.dists.logistic.cdf
+"@stdlib/stats/base/dists/logistic/entropy",base.dists.logistic.entropy
+"@stdlib/stats/base/dists/logistic/kurtosis",base.dists.logistic.kurtosis
+"@stdlib/stats/base/dists/logistic/logcdf",base.dists.logistic.logcdf
+"@stdlib/stats/base/dists/logistic/ctor",base.dists.logistic.Logistic
+"@stdlib/stats/base/dists/logistic/logpdf",base.dists.logistic.logpdf
+"@stdlib/stats/base/dists/logistic/mean",base.dists.logistic.mean
+"@stdlib/stats/base/dists/logistic/median",base.dists.logistic.median
+"@stdlib/stats/base/dists/logistic/mgf",base.dists.logistic.mgf
+"@stdlib/stats/base/dists/logistic/mode",base.dists.logistic.mode
+"@stdlib/stats/base/dists/logistic/pdf",base.dists.logistic.pdf
+"@stdlib/stats/base/dists/logistic/quantile",base.dists.logistic.quantile
+"@stdlib/stats/base/dists/logistic/skewness",base.dists.logistic.skewness
+"@stdlib/stats/base/dists/logistic/stdev",base.dists.logistic.stdev
+"@stdlib/stats/base/dists/logistic/variance",base.dists.logistic.variance
+"@stdlib/stats/base/dists/lognormal/cdf",base.dists.lognormal.cdf
+"@stdlib/stats/base/dists/lognormal/entropy",base.dists.lognormal.entropy
+"@stdlib/stats/base/dists/lognormal/kurtosis",base.dists.lognormal.kurtosis
+"@stdlib/stats/base/dists/lognormal/ctor",base.dists.lognormal.LogNormal
+"@stdlib/stats/base/dists/lognormal/logpdf",base.dists.lognormal.logpdf
+"@stdlib/stats/base/dists/lognormal/mean",base.dists.lognormal.mean
+"@stdlib/stats/base/dists/lognormal/median",base.dists.lognormal.median
+"@stdlib/stats/base/dists/lognormal/mode",base.dists.lognormal.mode
+"@stdlib/stats/base/dists/lognormal/pdf",base.dists.lognormal.pdf
+"@stdlib/stats/base/dists/lognormal/quantile",base.dists.lognormal.quantile
+"@stdlib/stats/base/dists/lognormal/skewness",base.dists.lognormal.skewness
+"@stdlib/stats/base/dists/lognormal/stdev",base.dists.lognormal.stdev
+"@stdlib/stats/base/dists/lognormal/variance",base.dists.lognormal.variance
+"@stdlib/stats/base/dists/negative-binomial/cdf",base.dists.negativeBinomial.cdf
+"@stdlib/stats/base/dists/negative-binomial/kurtosis",base.dists.negativeBinomial.kurtosis
+"@stdlib/stats/base/dists/negative-binomial/logpmf",base.dists.negativeBinomial.logpmf
+"@stdlib/stats/base/dists/negative-binomial/mean",base.dists.negativeBinomial.mean
+"@stdlib/stats/base/dists/negative-binomial/mgf",base.dists.negativeBinomial.mgf
+"@stdlib/stats/base/dists/negative-binomial/mode",base.dists.negativeBinomial.mode
+"@stdlib/stats/base/dists/negative-binomial/ctor",base.dists.negativeBinomial.NegativeBinomial
+"@stdlib/stats/base/dists/negative-binomial/pmf",base.dists.negativeBinomial.pmf
+"@stdlib/stats/base/dists/negative-binomial/quantile",base.dists.negativeBinomial.quantile
+"@stdlib/stats/base/dists/negative-binomial/skewness",base.dists.negativeBinomial.skewness
+"@stdlib/stats/base/dists/negative-binomial/stdev",base.dists.negativeBinomial.stdev
+"@stdlib/stats/base/dists/negative-binomial/variance",base.dists.negativeBinomial.variance
+"@stdlib/stats/base/dists/normal/cdf",base.dists.normal.cdf
+"@stdlib/stats/base/dists/normal/entropy",base.dists.normal.entropy
+"@stdlib/stats/base/dists/normal/kurtosis",base.dists.normal.kurtosis
+"@stdlib/stats/base/dists/normal/logpdf",base.dists.normal.logpdf
+"@stdlib/stats/base/dists/normal/mean",base.dists.normal.mean
+"@stdlib/stats/base/dists/normal/median",base.dists.normal.median
+"@stdlib/stats/base/dists/normal/mgf",base.dists.normal.mgf
+"@stdlib/stats/base/dists/normal/mode",base.dists.normal.mode
+"@stdlib/stats/base/dists/normal/ctor",base.dists.normal.Normal
+"@stdlib/stats/base/dists/normal/pdf",base.dists.normal.pdf
+"@stdlib/stats/base/dists/normal/quantile",base.dists.normal.quantile
+"@stdlib/stats/base/dists/normal/skewness",base.dists.normal.skewness
+"@stdlib/stats/base/dists/normal/stdev",base.dists.normal.stdev
+"@stdlib/stats/base/dists/normal/variance",base.dists.normal.variance
+"@stdlib/stats/base/dists/pareto-type1/cdf",base.dists.pareto1.cdf
+"@stdlib/stats/base/dists/pareto-type1/entropy",base.dists.pareto1.entropy
+"@stdlib/stats/base/dists/pareto-type1/kurtosis",base.dists.pareto1.kurtosis
+"@stdlib/stats/base/dists/pareto-type1/logcdf",base.dists.pareto1.logcdf
+"@stdlib/stats/base/dists/pareto-type1/logpdf",base.dists.pareto1.logpdf
+"@stdlib/stats/base/dists/pareto-type1/mean",base.dists.pareto1.mean
+"@stdlib/stats/base/dists/pareto-type1/median",base.dists.pareto1.median
+"@stdlib/stats/base/dists/pareto-type1/mode",base.dists.pareto1.mode
+"@stdlib/stats/base/dists/pareto-type1/ctor",base.dists.pareto1.Pareto1
+"@stdlib/stats/base/dists/pareto-type1/pdf",base.dists.pareto1.pdf
+"@stdlib/stats/base/dists/pareto-type1/quantile",base.dists.pareto1.quantile
+"@stdlib/stats/base/dists/pareto-type1/skewness",base.dists.pareto1.skewness
+"@stdlib/stats/base/dists/pareto-type1/variance",base.dists.pareto1.variance
+"@stdlib/stats/base/dists/poisson/cdf",base.dists.poisson.cdf
+"@stdlib/stats/base/dists/poisson/entropy",base.dists.poisson.entropy
+"@stdlib/stats/base/dists/poisson/kurtosis",base.dists.poisson.kurtosis
+"@stdlib/stats/base/dists/poisson/logpmf",base.dists.poisson.logpmf
+"@stdlib/stats/base/dists/poisson/mean",base.dists.poisson.mean
+"@stdlib/stats/base/dists/poisson/median",base.dists.poisson.median
+"@stdlib/stats/base/dists/poisson/mgf",base.dists.poisson.mgf
+"@stdlib/stats/base/dists/poisson/mode",base.dists.poisson.mode
+"@stdlib/stats/base/dists/poisson/pmf",base.dists.poisson.pmf
+"@stdlib/stats/base/dists/poisson/ctor",base.dists.poisson.Poisson
+"@stdlib/stats/base/dists/poisson/quantile",base.dists.poisson.quantile
+"@stdlib/stats/base/dists/poisson/skewness",base.dists.poisson.skewness
+"@stdlib/stats/base/dists/poisson/stdev",base.dists.poisson.stdev
+"@stdlib/stats/base/dists/poisson/variance",base.dists.poisson.variance
+"@stdlib/stats/base/dists/rayleigh/cdf",base.dists.rayleigh.cdf
+"@stdlib/stats/base/dists/rayleigh/entropy",base.dists.rayleigh.entropy
+"@stdlib/stats/base/dists/rayleigh/kurtosis",base.dists.rayleigh.kurtosis
+"@stdlib/stats/base/dists/rayleigh/logcdf",base.dists.rayleigh.logcdf
+"@stdlib/stats/base/dists/rayleigh/logpdf",base.dists.rayleigh.logpdf
+"@stdlib/stats/base/dists/rayleigh/mean",base.dists.rayleigh.mean
+"@stdlib/stats/base/dists/rayleigh/median",base.dists.rayleigh.median
+"@stdlib/stats/base/dists/rayleigh/mgf",base.dists.rayleigh.mgf
+"@stdlib/stats/base/dists/rayleigh/mode",base.dists.rayleigh.mode
+"@stdlib/stats/base/dists/rayleigh/pdf",base.dists.rayleigh.pdf
+"@stdlib/stats/base/dists/rayleigh/quantile",base.dists.rayleigh.quantile
+"@stdlib/stats/base/dists/rayleigh/ctor",base.dists.rayleigh.Rayleigh
+"@stdlib/stats/base/dists/rayleigh/skewness",base.dists.rayleigh.skewness
+"@stdlib/stats/base/dists/rayleigh/stdev",base.dists.rayleigh.stdev
+"@stdlib/stats/base/dists/rayleigh/variance",base.dists.rayleigh.variance
+"@stdlib/stats/base/dists/t/cdf",base.dists.t.cdf
+"@stdlib/stats/base/dists/t/entropy",base.dists.t.entropy
+"@stdlib/stats/base/dists/t/kurtosis",base.dists.t.kurtosis
+"@stdlib/stats/base/dists/t/mean",base.dists.t.mean
+"@stdlib/stats/base/dists/t/median",base.dists.t.median
+"@stdlib/stats/base/dists/t/mode",base.dists.t.mode
+"@stdlib/stats/base/dists/t/pdf",base.dists.t.pdf
+"@stdlib/stats/base/dists/t/quantile",base.dists.t.quantile
+"@stdlib/stats/base/dists/t/skewness",base.dists.t.skewness
+"@stdlib/stats/base/dists/t/stdev",base.dists.t.stdev
+"@stdlib/stats/base/dists/t/ctor",base.dists.t.T
+"@stdlib/stats/base/dists/t/variance",base.dists.t.variance
+"@stdlib/stats/base/dists/triangular/cdf",base.dists.triangular.cdf
+"@stdlib/stats/base/dists/triangular/entropy",base.dists.triangular.entropy
+"@stdlib/stats/base/dists/triangular/kurtosis",base.dists.triangular.kurtosis
+"@stdlib/stats/base/dists/triangular/logcdf",base.dists.triangular.logcdf
+"@stdlib/stats/base/dists/triangular/logpdf",base.dists.triangular.logpdf
+"@stdlib/stats/base/dists/triangular/mean",base.dists.triangular.mean
+"@stdlib/stats/base/dists/triangular/median",base.dists.triangular.median
+"@stdlib/stats/base/dists/triangular/mgf",base.dists.triangular.mgf
+"@stdlib/stats/base/dists/triangular/mode",base.dists.triangular.mode
+"@stdlib/stats/base/dists/triangular/pdf",base.dists.triangular.pdf
+"@stdlib/stats/base/dists/triangular/quantile",base.dists.triangular.quantile
+"@stdlib/stats/base/dists/triangular/skewness",base.dists.triangular.skewness
+"@stdlib/stats/base/dists/triangular/stdev",base.dists.triangular.stdev
+"@stdlib/stats/base/dists/triangular/ctor",base.dists.triangular.Triangular
+"@stdlib/stats/base/dists/triangular/variance",base.dists.triangular.variance
+"@stdlib/stats/base/dists/uniform/cdf",base.dists.uniform.cdf
+"@stdlib/stats/base/dists/uniform/entropy",base.dists.uniform.entropy
+"@stdlib/stats/base/dists/uniform/kurtosis",base.dists.uniform.kurtosis
+"@stdlib/stats/base/dists/uniform/logcdf",base.dists.uniform.logcdf
+"@stdlib/stats/base/dists/uniform/logpdf",base.dists.uniform.logpdf
+"@stdlib/stats/base/dists/uniform/mean",base.dists.uniform.mean
+"@stdlib/stats/base/dists/uniform/median",base.dists.uniform.median
+"@stdlib/stats/base/dists/uniform/mgf",base.dists.uniform.mgf
+"@stdlib/stats/base/dists/uniform/pdf",base.dists.uniform.pdf
+"@stdlib/stats/base/dists/uniform/quantile",base.dists.uniform.quantile
+"@stdlib/stats/base/dists/uniform/skewness",base.dists.uniform.skewness
+"@stdlib/stats/base/dists/uniform/stdev",base.dists.uniform.stdev
+"@stdlib/stats/base/dists/uniform/ctor",base.dists.uniform.Uniform
+"@stdlib/stats/base/dists/uniform/variance",base.dists.uniform.variance
+"@stdlib/stats/base/dists/weibull/cdf",base.dists.weibull.cdf
+"@stdlib/stats/base/dists/weibull/entropy",base.dists.weibull.entropy
+"@stdlib/stats/base/dists/weibull/kurtosis",base.dists.weibull.kurtosis
+"@stdlib/stats/base/dists/weibull/logcdf",base.dists.weibull.logcdf
+"@stdlib/stats/base/dists/weibull/logpdf",base.dists.weibull.logpdf
+"@stdlib/stats/base/dists/weibull/mean",base.dists.weibull.mean
+"@stdlib/stats/base/dists/weibull/median",base.dists.weibull.median
+"@stdlib/stats/base/dists/weibull/mgf",base.dists.weibull.mgf
+"@stdlib/stats/base/dists/weibull/mode",base.dists.weibull.mode
+"@stdlib/stats/base/dists/weibull/pdf",base.dists.weibull.pdf
+"@stdlib/stats/base/dists/weibull/quantile",base.dists.weibull.quantile
+"@stdlib/stats/base/dists/weibull/skewness",base.dists.weibull.skewness
+"@stdlib/stats/base/dists/weibull/stdev",base.dists.weibull.stdev
+"@stdlib/stats/base/dists/weibull/variance",base.dists.weibull.variance
+"@stdlib/stats/base/dists/weibull/ctor",base.dists.weibull.Weibull
+"@stdlib/math/base/special/ellipe",base.ellipe
+"@stdlib/math/base/special/ellipk",base.ellipk
+"@stdlib/math/base/utils/float64-epsilon-difference",base.epsdiff
+"@stdlib/math/base/special/erf",base.erf
+"@stdlib/math/base/special/erfc",base.erfc
+"@stdlib/math/base/special/erfcinv",base.erfcinv
+"@stdlib/math/base/special/erfinv",base.erfinv
+"@stdlib/math/base/special/dirichlet-eta",base.eta
+"@stdlib/math/base/tools/evalpoly",base.evalpoly
+"@stdlib/math/base/tools/evalrational",base.evalrational
+"@stdlib/math/base/special/exp",base.exp
+"@stdlib/math/base/special/exp2",base.exp2
+"@stdlib/math/base/special/exp10",base.exp10
+"@stdlib/math/base/special/expit",base.expit
+"@stdlib/math/base/special/expm1",base.expm1
+"@stdlib/math/base/special/expm1rel",base.expm1rel
+"@stdlib/number/float64/base/exponent",base.exponent
+"@stdlib/number/float32/base/exponent",base.exponentf
+"@stdlib/math/base/special/factorial",base.factorial
+"@stdlib/math/base/special/factorialln",base.factorialln
+"@stdlib/math/base/special/falling-factorial",base.fallingFactorial
+"@stdlib/math/base/special/fibonacci",base.fibonacci
+"@stdlib/math/base/special/fibonacci-index",base.fibonacciIndex
+"@stdlib/math/base/tools/fibpoly",base.fibpoly
+"@stdlib/math/base/special/flipsign",base.flipsign
+"@stdlib/number/float32/base/to-int32",base.float32ToInt32
+"@stdlib/number/float32/base/to-uint32",base.float32ToUint32
+"@stdlib/number/float64/base/to-float32",base.float64ToFloat32
+"@stdlib/number/float64/base/to-int32",base.float64ToInt32
+"@stdlib/number/float64/base/to-uint32",base.float64ToUint32
+"@stdlib/math/base/special/floor",base.floor
+"@stdlib/math/base/special/floor2",base.floor2
+"@stdlib/math/base/special/floor10",base.floor10
+"@stdlib/math/base/special/floorb",base.floorb
+"@stdlib/math/base/special/floorn",base.floorn
+"@stdlib/math/base/special/floorsd",base.floorsd
+"@stdlib/math/base/special/fresnel",base.fresnel
+"@stdlib/math/base/special/fresnelc",base.fresnelc
+"@stdlib/math/base/special/fresnels",base.fresnels
+"@stdlib/math/base/special/frexp",base.frexp
+"@stdlib/number/float64/base/from-binary-string",base.fromBinaryString
+"@stdlib/number/float32/base/from-binary-string",base.fromBinaryStringf
+"@stdlib/number/uint8/base/from-binary-string",base.fromBinaryStringUint8
+"@stdlib/number/uint16/base/from-binary-string",base.fromBinaryStringUint16
+"@stdlib/number/uint32/base/from-binary-string",base.fromBinaryStringUint32
+"@stdlib/number/float32/base/from-word",base.fromWordf
+"@stdlib/number/float64/base/from-words",base.fromWords
+"@stdlib/math/base/special/gamma",base.gamma
+"@stdlib/math/base/special/gamma1pm1",base.gamma1pm1
+"@stdlib/math/base/special/gamma-delta-ratio",base.gammaDeltaRatio
+"@stdlib/math/base/special/gammainc",base.gammainc
+"@stdlib/math/base/special/gammaincinv",base.gammaincinv
+"@stdlib/math/base/special/gamma-lanczos-sum",base.gammaLanczosSum
+"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled",base.gammaLanczosSumExpGScaled
+"@stdlib/math/base/special/gammaln",base.gammaln
+"@stdlib/blas/base/gasum",base.gasum
+"@stdlib/blas/base/gaxpy",base.gaxpy
+"@stdlib/math/base/special/gcd",base.gcd
+"@stdlib/blas/base/gcopy",base.gcopy
+"@stdlib/number/float64/base/get-high-word",base.getHighWord
+"@stdlib/number/float64/base/get-low-word",base.getLowWord
+"@stdlib/math/base/special/hacovercos",base.hacovercos
+"@stdlib/math/base/special/hacoversin",base.hacoversin
+"@stdlib/math/base/special/havercos",base.havercos
+"@stdlib/math/base/special/haversin",base.haversin
+"@stdlib/math/base/special/heaviside",base.heaviside
+"@stdlib/math/base/tools/hermitepoly",base.hermitepoly
+"@stdlib/math/base/special/hypot",base.hypot
+"@stdlib/math/base/special/imul",base.imul
+"@stdlib/math/base/special/imuldw",base.imuldw
+"@stdlib/number/int32/base/to-uint32",base.int32ToUint32
+"@stdlib/math/base/special/inv",base.inv
+"@stdlib/math/base/assert/is-even",base.isEven
+"@stdlib/math/base/assert/int32-is-even",base.isEvenInt32
+"@stdlib/math/base/assert/is-finite",base.isFinite
+"@stdlib/math/base/assert/is-infinite",base.isInfinite
+"@stdlib/math/base/assert/is-integer",base.isInteger
+"@stdlib/math/base/assert/is-nan",base.isnan
+"@stdlib/math/base/assert/is-negative-integer",base.isNegativeInteger
+"@stdlib/math/base/assert/is-negative-zero",base.isNegativeZero
+"@stdlib/math/base/assert/is-nonnegative-integer",base.isNonNegativeInteger
+"@stdlib/math/base/assert/is-nonpositive-integer",base.isNonPositiveInteger
+"@stdlib/math/base/assert/is-odd",base.isOdd
+"@stdlib/math/base/assert/int32-is-odd",base.isOddInt32
+"@stdlib/math/base/assert/is-positive-integer",base.isPositiveInteger
+"@stdlib/math/base/assert/is-positive-zero",base.isPositiveZero
+"@stdlib/math/base/assert/uint32-is-pow2",base.isPow2Uint32
+"@stdlib/math/base/assert/is-probability",base.isProbability
+"@stdlib/math/base/assert/is-safe-integer",base.isSafeInteger
+"@stdlib/math/base/special/kernel-betainc",base.kernelBetainc
+"@stdlib/math/base/special/kernel-betaincinv",base.kernelBetaincinv
+"@stdlib/math/base/special/kernel-cos",base.kernelCos
+"@stdlib/math/base/special/kernel-sin",base.kernelSin
+"@stdlib/math/base/special/kernel-tan",base.kernelTan
+"@stdlib/math/base/special/kronecker-delta",base.kroneckerDelta
+"@stdlib/math/base/special/lcm",base.lcm
+"@stdlib/math/base/special/ldexp",base.ldexp
+"@stdlib/math/base/special/ln",base.ln
+"@stdlib/math/base/special/log",base.log
+"@stdlib/math/base/special/log1mexp",base.log1mexp
+"@stdlib/math/base/special/log1p",base.log1p
+"@stdlib/math/base/special/log1pexp",base.log1pexp
+"@stdlib/math/base/special/log2",base.log2
+"@stdlib/math/base/special/log10",base.log10
+"@stdlib/math/base/special/logaddexp",base.logaddexp
+"@stdlib/math/base/special/logit",base.logit
+"@stdlib/math/base/special/lucas",base.lucas
+"@stdlib/math/base/tools/lucaspoly",base.lucaspoly
+"@stdlib/math/base/special/max",base.max
+"@stdlib/math/base/special/maxabs",base.maxabs
+"@stdlib/math/base/special/min",base.min
+"@stdlib/math/base/special/minabs",base.minabs
+"@stdlib/math/base/special/minmax",base.minmax
+"@stdlib/math/base/special/minmaxabs",base.minmaxabs
+"@stdlib/math/base/special/modf",base.modf
+"@stdlib/ndarray/base/ctor",base.ndarray
+"@stdlib/ndarray/base/memoized-ctor",base.ndarrayMemoized
+"@stdlib/math/base/special/negafibonacci",base.negafibonacci
+"@stdlib/math/base/special/negalucas",base.negalucas
+"@stdlib/math/base/special/nonfibonacci",base.nonfibonacci
+"@stdlib/number/float64/base/normalize",base.normalize
+"@stdlib/number/float32/base/normalize",base.normalizef
+"@stdlib/math/base/tools/normhermitepoly",base.normhermitepoly
+"@stdlib/math/base/special/pdiff",base.pdiff
+"@stdlib/math/base/special/polygamma",base.polygamma
+"@stdlib/math/base/special/pow",base.pow
+"@stdlib/math/base/special/powm1",base.powm1
+"@stdlib/math/base/special/rad2deg",base.rad2deg
+"@stdlib/math/base/special/ramp",base.ramp
+"@stdlib/random/base/arcsine",base.random.arcsine
+"@stdlib/random/base/bernoulli",base.random.bernoulli
+"@stdlib/random/base/beta",base.random.beta
+"@stdlib/random/base/betaprime",base.random.betaprime
+"@stdlib/random/base/binomial",base.random.binomial
+"@stdlib/random/base/box-muller",base.random.boxMuller
+"@stdlib/random/base/cauchy",base.random.cauchy
+"@stdlib/random/base/chi",base.random.chi
+"@stdlib/random/base/chisquare",base.random.chisquare
+"@stdlib/random/base/cosine",base.random.cosine
+"@stdlib/random/base/discrete-uniform",base.random.discreteUniform
+"@stdlib/random/base/erlang",base.random.erlang
+"@stdlib/random/base/exponential",base.random.exponential
+"@stdlib/random/base/f",base.random.f
+"@stdlib/random/base/frechet",base.random.frechet
+"@stdlib/random/base/gamma",base.random.gamma
+"@stdlib/random/base/geometric",base.random.geometric
+"@stdlib/random/base/gumbel",base.random.gumbel
+"@stdlib/random/base/hypergeometric",base.random.hypergeometric
+"@stdlib/random/base/improved-ziggurat",base.random.improvedZiggurat
+"@stdlib/random/base/invgamma",base.random.invgamma
+"@stdlib/random/base/kumaraswamy",base.random.kumaraswamy
+"@stdlib/random/base/laplace",base.random.laplace
+"@stdlib/random/base/levy",base.random.levy
+"@stdlib/random/base/logistic",base.random.logistic
+"@stdlib/random/base/lognormal",base.random.lognormal
+"@stdlib/random/base/minstd",base.random.minstd
+"@stdlib/random/base/minstd-shuffle",base.random.minstdShuffle
+"@stdlib/random/base/mt19937",base.random.mt19937
+"@stdlib/random/base/negative-binomial",base.random.negativeBinomial
+"@stdlib/random/base/normal",base.random.normal
+"@stdlib/random/base/pareto-type1",base.random.pareto1
+"@stdlib/random/base/poisson",base.random.poisson
+"@stdlib/random/base/randi",base.random.randi
+"@stdlib/random/base/randn",base.random.randn
+"@stdlib/random/base/randu",base.random.randu
+"@stdlib/random/base/rayleigh",base.random.rayleigh
+"@stdlib/random/base/t",base.random.t
+"@stdlib/random/base/triangular",base.random.triangular
+"@stdlib/random/base/uniform",base.random.uniform
+"@stdlib/random/base/weibull",base.random.weibull
+"@stdlib/math/base/utils/relative-difference",base.reldiff
+"@stdlib/math/base/special/rempio2",base.rempio2
+"@stdlib/math/base/special/rising-factorial",base.risingFactorial
+"@stdlib/number/uint32/base/rotl",base.rotl32
+"@stdlib/number/uint32/base/rotr",base.rotr32
+"@stdlib/math/base/special/round",base.round
+"@stdlib/math/base/special/round2",base.round2
+"@stdlib/math/base/special/round10",base.round10
+"@stdlib/math/base/special/roundb",base.roundb
+"@stdlib/math/base/special/roundn",base.roundn
+"@stdlib/math/base/special/roundsd",base.roundsd
+"@stdlib/math/base/special/rsqrt",base.rsqrt
+"@stdlib/blas/base/sasum",base.sasum
+"@stdlib/blas/base/saxpy",base.saxpy
+"@stdlib/blas/base/scopy",base.scopy
+"@stdlib/number/float64/base/set-high-word",base.setHighWord
+"@stdlib/number/float64/base/set-low-word",base.setLowWord
+"@stdlib/math/base/special/sici",base.sici
+"@stdlib/number/float64/base/signbit",base.signbit
+"@stdlib/number/float32/base/signbit",base.signbitf
+"@stdlib/number/float32/base/significand",base.significandf
+"@stdlib/math/base/special/signum",base.signum
+"@stdlib/math/base/special/sin",base.sin
+"@stdlib/math/base/special/sinc",base.sinc
+"@stdlib/math/base/special/sincos",base.sincos
+"@stdlib/math/base/special/sincospi",base.sincospi
+"@stdlib/math/base/special/sinh",base.sinh
+"@stdlib/math/base/special/sinpi",base.sinpi
+"@stdlib/math/base/special/spence",base.spence
+"@stdlib/math/base/special/sqrt",base.sqrt
+"@stdlib/math/base/special/sqrt1pm1",base.sqrt1pm1
+"@stdlib/math/base/tools/sum-series",base.sumSeries
+"@stdlib/math/base/special/tan",base.tan
+"@stdlib/math/base/special/tanh",base.tanh
+"@stdlib/number/float64/base/to-binary-string",base.toBinaryString
+"@stdlib/number/float32/base/to-binary-string",base.toBinaryStringf
+"@stdlib/number/uint8/base/to-binary-string",base.toBinaryStringUint8
+"@stdlib/number/uint16/base/to-binary-string",base.toBinaryStringUint16
+"@stdlib/number/uint32/base/to-binary-string",base.toBinaryStringUint32
+"@stdlib/number/float32/base/to-word",base.toWordf
+"@stdlib/number/float64/base/to-words",base.toWords
+"@stdlib/math/base/special/trigamma",base.trigamma
+"@stdlib/math/base/special/trunc",base.trunc
+"@stdlib/math/base/special/trunc2",base.trunc2
+"@stdlib/math/base/special/trunc10",base.trunc10
+"@stdlib/math/base/special/truncb",base.truncb
+"@stdlib/math/base/special/truncn",base.truncn
+"@stdlib/math/base/special/truncsd",base.truncsd
+"@stdlib/math/base/special/uimul",base.uimul
+"@stdlib/math/base/special/uimuldw",base.uimuldw
+"@stdlib/number/uint32/base/to-int32",base.uint32ToInt32
+"@stdlib/math/base/special/vercos",base.vercos
+"@stdlib/math/base/special/versin",base.versin
+"@stdlib/math/base/special/wrap",base.wrap
+"@stdlib/math/base/special/xlog1py",base.xlog1py
+"@stdlib/math/base/special/xlogy",base.xlogy
+"@stdlib/math/base/special/riemann-zeta",base.zeta
+"@stdlib/datasets/berndt-cps-wages-1985",BERNDT_CPS_WAGES_1985
+"@stdlib/utils/bifurcate",bifurcate
+"@stdlib/utils/bifurcate-by",bifurcateBy
+"@stdlib/utils/async/bifurcate-by",bifurcateByAsync
+"@stdlib/utils/bifurcate-in",bifurcateIn
+"@stdlib/utils/bifurcate-own",bifurcateOwn
+"@stdlib/stats/binomial-test",binomialTest
+"@stdlib/buffer/ctor",Buffer
+"@stdlib/buffer/to-json",buffer2json
+"@stdlib/string/capitalize",capitalize
+"@stdlib/utils/capitalize-keys",capitalizeKeys
+"@stdlib/constants/math/float64-catalan",CATALAN
+"@stdlib/constants/math/float64-cbrt-eps",CBRT_EPS
+"@stdlib/process/chdir",chdir
+"@stdlib/stats/chi2gof",chi2gof
+"@stdlib/array/to-circular-iterator",circarray2iterator
+"@stdlib/streams/node/from-circular-array",circularArrayStream
+"@stdlib/utils/circular-buffer",CircularBuffer
+"@stdlib/datasets/cmudict",CMUDICT
+"@stdlib/complex/cmplx",complex
+"@stdlib/complex/float32",Complex64
+"@stdlib/constants/math/complex64-num-bytes",COMPLEX64_NUM_BYTES
+"@stdlib/array/complex64",Complex64Array
+"@stdlib/complex/float64",Complex128
+"@stdlib/constants/math/complex128-num-bytes",COMPLEX128_NUM_BYTES
+"@stdlib/array/complex128",Complex128Array
+"@stdlib/utils/compose",compose
+"@stdlib/utils/async/compose",composeAsync
+"@stdlib/os/configdir",configdir
+"@stdlib/complex/conj",conj
+"@stdlib/utils/constant-function",constantFunction
+"@stdlib/streams/node/from-constant",constantStream
+"@stdlib/utils/constructor-name",constructorName
+"@stdlib/assert/contains",contains
+"@stdlib/array/convert",convertArray
+"@stdlib/array/convert-same",convertArraySame
+"@stdlib/utils/convert-path",convertPath
+"@stdlib/utils/copy",copy
+"@stdlib/buffer/from-buffer",copyBuffer
+"@stdlib/utils/count-by",countBy
+"@stdlib/utils/async/count-by",countByAsync
+"@stdlib/utils/curry",curry
+"@stdlib/utils/curry-right",curryRight
+"@stdlib/process/cwd",cwd
+"@stdlib/datasets/dale-chall-new",DALE_CHALL_NEW
+"@stdlib/datasets",datasets
+"@stdlib/time/day-of-quarter",dayOfQuarter
+"@stdlib/time/day-of-year",dayOfYear
+"@stdlib/time/days-in-month",daysInMonth
+"@stdlib/time/days-in-year",daysInYear
+"@stdlib/streams/node/debug-sink",debugSinkStream
+"@stdlib/streams/node/debug",debugStream
+"@stdlib/assert/deep-equal",deepEqual
+"@stdlib/utils/deep-get",deepGet
+"@stdlib/assert/deep-has-own-property",deepHasOwnProp
+"@stdlib/assert/deep-has-property",deepHasProp
+"@stdlib/utils/deep-pluck",deepPluck
+"@stdlib/utils/deep-set",deepSet
+"@stdlib/utils/define-memoized-property",defineMemoizedProperty
+"@stdlib/utils/define-properties",defineProperties
+"@stdlib/utils/define-property",defineProperty
+"@stdlib/utils/dirname",dirname
+"@stdlib/utils/doubly-linked-list",DoublyLinkedList
+"@stdlib/utils/do-until",doUntil
+"@stdlib/utils/async/do-until",doUntilAsync
+"@stdlib/utils/do-until-each",doUntilEach
+"@stdlib/utils/do-until-each-right",doUntilEachRight
+"@stdlib/utils/do-while",doWhile
+"@stdlib/utils/async/do-while",doWhileAsync
+"@stdlib/utils/do-while-each",doWhileEach
+"@stdlib/utils/do-while-each-right",doWhileEachRight
+"@stdlib/constants/math/float64-e",E
+"@stdlib/streams/node/empty",emptyStream
+"@stdlib/string/ends-with",endsWith
+"@stdlib/utils/enumerable-properties",enumerableProperties
+"@stdlib/utils/enumerable-properties-in",enumerablePropertiesIn
+"@stdlib/utils/enumerable-property-symbols",enumerablePropertySymbols
+"@stdlib/utils/enumerable-property-symbols-in",enumerablePropertySymbolsIn
+"@stdlib/process/env",ENV
+"@stdlib/constants/math/float64-eps",EPS
+"@stdlib/error/to-json",error2json
+"@stdlib/constants/math/float64-eulergamma",EULERGAMMA
+"@stdlib/utils/every",every
+"@stdlib/utils/every-by",everyBy
+"@stdlib/utils/async/every-by",everyByAsync
+"@stdlib/utils/every-by-right",everyByRight
+"@stdlib/utils/async/every-by-right",everyByRightAsync
+"@stdlib/utils/eval",evil
+"@stdlib/fs/exists",exists
+"@stdlib/nlp/expand-contractions",expandContractions
+"@stdlib/utils/extname",extname
+"@stdlib/fastmath/special/abs",fastmath.abs
+"@stdlib/fastmath/special/acosh",fastmath.acosh
+"@stdlib/fastmath/special/alpha-max-plus-beta-min",fastmath.ampbm
+"@stdlib/fastmath/special/asinh",fastmath.asinh
+"@stdlib/fastmath/special/atanh",fastmath.atanh
+"@stdlib/fastmath/special/hypot",fastmath.hypot
+"@stdlib/fastmath/special/uint32-log2",fastmath.log2Uint32
+"@stdlib/fastmath/special/max",fastmath.max
+"@stdlib/fastmath/special/min",fastmath.min
+"@stdlib/fastmath/special/pow-int",fastmath.powint
+"@stdlib/fastmath/special/uint32-sqrt",fastmath.sqrtUint32
+"@stdlib/datasets/female-first-names-en",FEMALE_FIRST_NAMES_EN
+"@stdlib/utils/fifo",FIFO
+"@stdlib/utils/find",find
+"@stdlib/utils/flatten-array",flattenArray
+"@stdlib/utils/flatten-object",flattenObject
+"@stdlib/stats/fligner-test",flignerTest
+"@stdlib/constants/math/float16-cbrt-eps",FLOAT16_CBRT_EPS
+"@stdlib/constants/math/float16-eps",FLOAT16_EPS
+"@stdlib/constants/math/float16-exponent-bias",FLOAT16_EXPONENT_BIAS
+"@stdlib/constants/math/float16-max",FLOAT16_MAX
+"@stdlib/constants/math/float16-max-safe-integer",FLOAT16_MAX_SAFE_INTEGER
+"@stdlib/constants/math/float16-min-safe-integer",FLOAT16_MIN_SAFE_INTEGER
+"@stdlib/constants/math/float16-ninf",FLOAT16_NINF
+"@stdlib/constants/math/float16-num-bytes",FLOAT16_NUM_BYTES
+"@stdlib/constants/math/float16-pinf",FLOAT16_PINF
+"@stdlib/constants/math/float16-precision",FLOAT16_PRECISION
+"@stdlib/constants/math/float16-smallest-normal",FLOAT16_SMALLEST_NORMAL
+"@stdlib/constants/math/float16-smallest-subnormal",FLOAT16_SMALLEST_SUBNORMAL
+"@stdlib/constants/math/float16-sqrt-eps",FLOAT16_SQRT_EPS
+"@stdlib/constants/math/float32-cbrt-eps",FLOAT32_CBRT_EPS
+"@stdlib/constants/math/float32-eps",FLOAT32_EPS
+"@stdlib/constants/math/float32-exponent-bias",FLOAT32_EXPONENT_BIAS
+"@stdlib/constants/math/float32-max",FLOAT32_MAX
+"@stdlib/constants/math/float32-max-safe-integer",FLOAT32_MAX_SAFE_INTEGER
+"@stdlib/constants/math/float32-min-safe-integer",FLOAT32_MIN_SAFE_INTEGER
+"@stdlib/constants/math/float32-ninf",FLOAT32_NINF
+"@stdlib/constants/math/float32-num-bytes",FLOAT32_NUM_BYTES
+"@stdlib/constants/math/float32-pinf",FLOAT32_PINF
+"@stdlib/constants/math/float32-precision",FLOAT32_PRECISION
+"@stdlib/constants/math/float32-smallest-normal",FLOAT32_SMALLEST_NORMAL
+"@stdlib/constants/math/float32-smallest-subnormal",FLOAT32_SMALLEST_SUBNORMAL
+"@stdlib/constants/math/float32-sqrt-eps",FLOAT32_SQRT_EPS
+"@stdlib/array/float32",Float32Array
+"@stdlib/constants/math/float64-exponent-bias",FLOAT64_EXPONENT_BIAS
+"@stdlib/constants/math/float64-high-word-exponent-mask",FLOAT64_HIGH_WORD_EXPONENT_MASK
+"@stdlib/constants/math/float64-high-word-significand-mask",FLOAT64_HIGH_WORD_SIGNIFICAND_MASK
+"@stdlib/constants/math/float64-max",FLOAT64_MAX
+"@stdlib/constants/math/float64-max-base2-exponent",FLOAT64_MAX_BASE2_EXPONENT
+"@stdlib/constants/math/float64-max-base2-exponent-subnormal",FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL
+"@stdlib/constants/math/float64-max-base10-exponent",FLOAT64_MAX_BASE10_EXPONENT
+"@stdlib/constants/math/float64-max-base10-exponent-subnormal",FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL
+"@stdlib/constants/math/float64-max-ln",FLOAT64_MAX_LN
+"@stdlib/constants/math/float64-max-safe-fibonacci",FLOAT64_MAX_SAFE_FIBONACCI
+"@stdlib/constants/math/float64-max-safe-integer",FLOAT64_MAX_SAFE_INTEGER
+"@stdlib/constants/math/float64-max-safe-lucas",FLOAT64_MAX_SAFE_LUCAS
+"@stdlib/constants/math/float64-max-safe-nth-fibonacci",FLOAT64_MAX_SAFE_NTH_FIBONACCI
+"@stdlib/constants/math/float64-max-safe-nth-lucas",FLOAT64_MAX_SAFE_NTH_LUCAS
+"@stdlib/constants/math/float64-min-base2-exponent",FLOAT64_MIN_BASE2_EXPONENT
+"@stdlib/constants/math/float64-min-base2-exponent-subnormal",FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL
+"@stdlib/constants/math/float64-min-base10-exponent",FLOAT64_MIN_BASE10_EXPONENT
+"@stdlib/constants/math/float64-min-base10-exponent-subnormal",FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL
+"@stdlib/constants/math/float64-min-ln",FLOAT64_MIN_LN
+"@stdlib/constants/math/float64-min-safe-integer",FLOAT64_MIN_SAFE_INTEGER
+"@stdlib/constants/math/float64-num-bytes",FLOAT64_NUM_BYTES
+"@stdlib/constants/math/float64-precision",FLOAT64_PRECISION
+"@stdlib/constants/math/float64-smallest-normal",FLOAT64_SMALLEST_NORMAL
+"@stdlib/constants/math/float64-smallest-subnormal",FLOAT64_SMALLEST_SUBNORMAL
+"@stdlib/array/float64",Float64Array
+"@stdlib/utils/for-each",forEach
+"@stdlib/utils/async/for-each",forEachAsync
+"@stdlib/utils/for-each-right",forEachRight
+"@stdlib/utils/async/for-each-right",forEachRightAsync
+"@stdlib/utils/for-in",forIn
+"@stdlib/utils/for-own",forOwn
+"@stdlib/constants/math/float64-fourth-pi",FOURTH_PI
+"@stdlib/constants/math/float64-fourth-root-eps",FOURTH_ROOT_EPS
+"@stdlib/datasets/frb-sf-wage-rigidity",FRB_SF_WAGE_RIGIDITY
+"@stdlib/string/from-code-point",fromCodePoint
+"@stdlib/utils/function-name",functionName
+"@stdlib/utils/function-sequence",functionSequence
+"@stdlib/utils/async/function-sequence",functionSequenceAsync
+"@stdlib/constants/math/float64-gamma-lanczos-g",GAMMA_LANCZOS_G
+"@stdlib/process/getegid",getegid
+"@stdlib/process/geteuid",geteuid
+"@stdlib/process/getgid",getgid
+"@stdlib/utils/global",getGlobal
+"@stdlib/utils/get-prototype-of",getPrototypeOf
+"@stdlib/process/getuid",getuid
+"@stdlib/constants/math/float64-glaisher-kinkelin",GLAISHER
+"@stdlib/utils/group",group
+"@stdlib/utils/group-by",groupBy
+"@stdlib/utils/async/group-by",groupByAsync
+"@stdlib/utils/group-in",groupIn
+"@stdlib/utils/group-own",groupOwn
+"@stdlib/constants/math/float64-half-ln-two",HALF_LN2
+"@stdlib/constants/math/float64-half-pi",HALF_PI
+"@stdlib/datasets/harrison-boston-house-prices",HARRISON_BOSTON_HOUSE_PRICES
+"@stdlib/datasets/harrison-boston-house-prices-corrected",HARRISON_BOSTON_HOUSE_PRICES_CORRECTED
+"@stdlib/assert/has-arraybuffer-support",hasArrayBufferSupport
+"@stdlib/assert/has-async-await-support",hasAsyncAwaitSupport
+"@stdlib/assert/has-async-iterator-symbol-support",hasAsyncIteratorSymbolSupport
+"@stdlib/assert/has-class-support",hasClassSupport
+"@stdlib/assert/has-define-properties-support",hasDefinePropertiesSupport
+"@stdlib/assert/has-define-property-support",hasDefinePropertySupport
+"@stdlib/assert/has-float32array-support",hasFloat32ArraySupport
+"@stdlib/assert/has-float64array-support",hasFloat64ArraySupport
+"@stdlib/assert/has-function-name-support",hasFunctionNameSupport
+"@stdlib/assert/has-generator-support",hasGeneratorSupport
+"@stdlib/assert/has-int8array-support",hasInt8ArraySupport
+"@stdlib/assert/has-int16array-support",hasInt16ArraySupport
+"@stdlib/assert/has-int32array-support",hasInt32ArraySupport
+"@stdlib/assert/has-iterator-symbol-support",hasIteratorSymbolSupport
+"@stdlib/assert/has-map-support",hasMapSupport
+"@stdlib/assert/has-node-buffer-support",hasNodeBufferSupport
+"@stdlib/assert/has-own-property",hasOwnProp
+"@stdlib/assert/has-property",hasProp
+"@stdlib/assert/has-proxy-support",hasProxySupport
+"@stdlib/assert/has-set-support",hasSetSupport
+"@stdlib/assert/has-sharedarraybuffer-support",hasSharedArrayBufferSupport
+"@stdlib/assert/has-symbol-support",hasSymbolSupport
+"@stdlib/assert/has-tostringtag-support",hasToStringTagSupport
+"@stdlib/assert/has-uint8array-support",hasUint8ArraySupport
+"@stdlib/assert/has-uint8clampedarray-support",hasUint8ClampedArraySupport
+"@stdlib/assert/has-uint16array-support",hasUint16ArraySupport
+"@stdlib/assert/has-uint32array-support",hasUint32ArraySupport
+"@stdlib/assert/has-weakmap-support",hasWeakMapSupport
+"@stdlib/assert/has-weakset-support",hasWeakSetSupport
+"@stdlib/assert/has-wasm-support",hasWebAssemblySupport
+"@stdlib/datasets/herndon-venus-semidiameters",HERNDON_VENUS_SEMIDIAMETERS
+"@stdlib/os/homedir",homedir
+"@stdlib/constants/time/hours-in-day",HOURS_IN_DAY
+"@stdlib/constants/time/hours-in-week",HOURS_IN_WEEK
+"@stdlib/time/hours-in-month",hoursInMonth
+"@stdlib/time/hours-in-year",hoursInYear
+"@stdlib/net/http-server",httpServer
+"@stdlib/utils/identity-function",identity
+"@stdlib/utils/if-else",ifelse
+"@stdlib/utils/async/if-else",ifelseAsync
+"@stdlib/utils/if-then",ifthen
+"@stdlib/utils/async/if-then",ifthenAsync
+"@stdlib/complex/imag",imag
+"@stdlib/datasets/img-acanthus-mollis",IMG_ACANTHUS_MOLLIS
+"@stdlib/datasets/img-airplane-from-above",IMG_AIRPLANE_FROM_ABOVE
+"@stdlib/datasets/img-allium-oreophilum",IMG_ALLIUM_OREOPHILUM
+"@stdlib/datasets/img-black-canyon",IMG_BLACK_CANYON
+"@stdlib/datasets/img-dust-bowl-home",IMG_DUST_BOWL_HOME
+"@stdlib/datasets/img-french-alpine-landscape",IMG_FRENCH_ALPINE_LANDSCAPE
+"@stdlib/datasets/img-locomotion-house-cat",IMG_LOCOMOTION_HOUSE_CAT
+"@stdlib/datasets/img-locomotion-nude-male",IMG_LOCOMOTION_NUDE_MALE
+"@stdlib/datasets/img-march-pastoral",IMG_MARCH_PASTORAL
+"@stdlib/datasets/img-nagasaki-boats",IMG_NAGASAKI_BOATS
+"@stdlib/stats/incr/apcorr",incrapcorr
+"@stdlib/stats/incr/count",incrcount
+"@stdlib/stats/incr/covariance",incrcovariance
+"@stdlib/stats/incr/covmat",incrcovmat
+"@stdlib/stats/incr/cv",incrcv
+"@stdlib/stats/incr/ewmean",increwmean
+"@stdlib/stats/incr/ewstdev",increwstdev
+"@stdlib/stats/incr/ewvariance",increwvariance
+"@stdlib/stats/incr/gmean",incrgmean
+"@stdlib/stats/incr/grubbs",incrgrubbs
+"@stdlib/stats/incr/hmean",incrhmean
+"@stdlib/ml/incr/kmeans",incrkmeans
+"@stdlib/stats/incr/kurtosis",incrkurtosis
+"@stdlib/stats/incr/maape",incrmaape
+"@stdlib/stats/incr/mae",incrmae
+"@stdlib/stats/incr/mapcorr",incrmapcorr
+"@stdlib/stats/incr/mape",incrmape
+"@stdlib/stats/incr/max",incrmax
+"@stdlib/stats/incr/maxabs",incrmaxabs
+"@stdlib/stats/incr/mcovariance",incrmcovariance
+"@stdlib/stats/incr/mcv",incrmcv
+"@stdlib/stats/incr/mda",incrmda
+"@stdlib/stats/incr/me",incrme
+"@stdlib/stats/incr/mean",incrmean
+"@stdlib/stats/incr/meanabs",incrmeanabs
+"@stdlib/stats/incr/meanabs2",incrmeanabs2
+"@stdlib/stats/incr/meanstdev",incrmeanstdev
+"@stdlib/stats/incr/meanvar",incrmeanvar
+"@stdlib/stats/incr/mgmean",incrmgmean
+"@stdlib/stats/incr/mgrubbs",incrmgrubbs
+"@stdlib/stats/incr/mhmean",incrmhmean
+"@stdlib/stats/incr/midrange",incrmidrange
+"@stdlib/stats/incr/min",incrmin
+"@stdlib/stats/incr/minabs",incrminabs
+"@stdlib/stats/incr/minmax",incrminmax
+"@stdlib/stats/incr/minmaxabs",incrminmaxabs
+"@stdlib/stats/incr/mmaape",incrmmaape
+"@stdlib/stats/incr/mmae",incrmmae
+"@stdlib/stats/incr/mmape",incrmmape
+"@stdlib/stats/incr/mmax",incrmmax
+"@stdlib/stats/incr/mmaxabs",incrmmaxabs
+"@stdlib/stats/incr/mmda",incrmmda
+"@stdlib/stats/incr/mme",incrmme
+"@stdlib/stats/incr/mmean",incrmmean
+"@stdlib/stats/incr/mmeanabs",incrmmeanabs
+"@stdlib/stats/incr/mmeanabs2",incrmmeanabs2
+"@stdlib/stats/incr/mmeanstdev",incrmmeanstdev
+"@stdlib/stats/incr/mmeanvar",incrmmeanvar
+"@stdlib/stats/incr/mmidrange",incrmmidrange
+"@stdlib/stats/incr/mmin",incrmmin
+"@stdlib/stats/incr/mminabs",incrmminabs
+"@stdlib/stats/incr/mminmax",incrmminmax
+"@stdlib/stats/incr/mminmaxabs",incrmminmaxabs
+"@stdlib/stats/incr/mmpe",incrmmpe
+"@stdlib/stats/incr/mmse",incrmmse
+"@stdlib/stats/incr/mpcorr",incrmpcorr
+"@stdlib/stats/incr/mpcorr2",incrmpcorr2
+"@stdlib/stats/incr/mpcorrdist",incrmpcorrdist
+"@stdlib/stats/incr/mpe",incrmpe
+"@stdlib/stats/incr/mprod",incrmprod
+"@stdlib/stats/incr/mrange",incrmrange
+"@stdlib/stats/incr/mrmse",incrmrmse
+"@stdlib/stats/incr/mrss",incrmrss
+"@stdlib/stats/incr/mse",incrmse
+"@stdlib/stats/incr/mstdev",incrmstdev
+"@stdlib/stats/incr/msum",incrmsum
+"@stdlib/stats/incr/msumabs",incrmsumabs
+"@stdlib/stats/incr/msumabs2",incrmsumabs2
+"@stdlib/stats/incr/msummary",incrmsummary
+"@stdlib/stats/incr/msumprod",incrmsumprod
+"@stdlib/stats/incr/mvariance",incrmvariance
+"@stdlib/stats/incr/mvmr",incrmvmr
+"@stdlib/stats/incr/pcorr",incrpcorr
+"@stdlib/stats/incr/pcorr2",incrpcorr2
+"@stdlib/stats/incr/pcorrdist",incrpcorrdist
+"@stdlib/stats/incr/pcorrdistmat",incrpcorrdistmat
+"@stdlib/stats/incr/pcorrmat",incrpcorrmat
+"@stdlib/stats/incr/prod",incrprod
+"@stdlib/stats/incr/range",incrrange
+"@stdlib/stats/incr/rmse",incrrmse
+"@stdlib/stats/incr/rss",incrrss
+"@stdlib/stats/incr/skewness",incrskewness
+"@stdlib/math/utils/incrspace",incrspace
+"@stdlib/stats/incr/stdev",incrstdev
+"@stdlib/stats/incr/sum",incrsum
+"@stdlib/stats/incr/sumabs",incrsumabs
+"@stdlib/stats/incr/sumabs2",incrsumabs2
+"@stdlib/stats/incr/summary",incrsummary
+"@stdlib/stats/incr/sumprod",incrsumprod
+"@stdlib/stats/incr/variance",incrvariance
+"@stdlib/stats/incr/vmr",incrvmr
+"@stdlib/stats/incr/wmean",incrwmean
+"@stdlib/ndarray/ind2sub",ind2sub
+"@stdlib/utils/index-of",indexOf
+"@stdlib/utils/inherit",inherit
+"@stdlib/utils/inherited-enumerable-properties",inheritedEnumerableProperties
+"@stdlib/utils/inherited-enumerable-property-symbols",inheritedEnumerablePropertySymbols
+"@stdlib/utils/inherited-keys",inheritedKeys
+"@stdlib/utils/inherited-nonenumerable-properties",inheritedNonEnumerableProperties
+"@stdlib/utils/inherited-nonenumerable-property-names",inheritedNonEnumerablePropertyNames
+"@stdlib/utils/inherited-nonenumerable-property-symbols",inheritedNonEnumerablePropertySymbols
+"@stdlib/utils/inherited-properties",inheritedProperties
+"@stdlib/utils/inherited-property-descriptor",inheritedPropertyDescriptor
+"@stdlib/utils/inherited-property-descriptors",inheritedPropertyDescriptors
+"@stdlib/utils/inherited-property-names",inheritedPropertyNames
+"@stdlib/utils/inherited-property-symbols",inheritedPropertySymbols
+"@stdlib/utils/inherited-writable-properties",inheritedWritableProperties
+"@stdlib/utils/inherited-writable-property-names",inheritedWritablePropertyNames
+"@stdlib/utils/inherited-writable-property-symbols",inheritedWritablePropertySymbols
+"@stdlib/utils/inmap",inmap
+"@stdlib/utils/async/inmap",inmapAsync
+"@stdlib/utils/inmap-right",inmapRight
+"@stdlib/utils/async/inmap-right",inmapRightAsync
+"@stdlib/streams/node/inspect-sink",inspectSinkStream
+"@stdlib/streams/node/inspect",inspectStream
+"@stdlib/assert/instance-of",instanceOf
+"@stdlib/constants/math/int8-max",INT8_MAX
+"@stdlib/constants/math/int8-min",INT8_MIN
+"@stdlib/constants/math/int8-num-bytes",INT8_NUM_BYTES
+"@stdlib/array/int8",Int8Array
+"@stdlib/constants/math/int16-max",INT16_MAX
+"@stdlib/constants/math/int16-min",INT16_MIN
+"@stdlib/constants/math/int16-num-bytes",INT16_NUM_BYTES
+"@stdlib/array/int16",Int16Array
+"@stdlib/constants/math/int32-max",INT32_MAX
+"@stdlib/constants/math/int32-min",INT32_MIN
+"@stdlib/constants/math/int32-num-bytes",INT32_NUM_BYTES
+"@stdlib/array/int32",Int32Array
+"@stdlib/assert/is-big-endian",IS_BIG_ENDIAN
+"@stdlib/assert/is-browser",IS_BROWSER
+"@stdlib/assert/is-darwin",IS_DARWIN
+"@stdlib/assert/is-electron",IS_ELECTRON
+"@stdlib/assert/is-electron-main",IS_ELECTRON_MAIN
+"@stdlib/assert/is-electron-renderer",IS_ELECTRON_RENDERER
+"@stdlib/assert/is-little-endian",IS_LITTLE_ENDIAN
+"@stdlib/assert/is-node",IS_NODE
+"@stdlib/assert/is-web-worker",IS_WEB_WORKER
+"@stdlib/assert/is-windows",IS_WINDOWS
+"@stdlib/assert/is-absolute-path",isAbsolutePath
+"@stdlib/assert/is-accessor-property",isAccessorProperty
+"@stdlib/assert/is-accessor-property-in",isAccessorPropertyIn
+"@stdlib/assert/is-alphagram",isAlphagram
+"@stdlib/assert/is-alphanumeric",isAlphaNumeric
+"@stdlib/assert/is-anagram",isAnagram
+"@stdlib/assert/is-arguments",isArguments
+"@stdlib/assert/is-array",isArray
+"@stdlib/assert/is-array-array",isArrayArray
+"@stdlib/assert/is-arraybuffer",isArrayBuffer
+"@stdlib/assert/is-array-length",isArrayLength
+"@stdlib/assert/is-array-like",isArrayLike
+"@stdlib/assert/is-array-like-object",isArrayLikeObject
+"@stdlib/assert/is-ascii",isASCII
+"@stdlib/assert/is-between",isBetween
+"@stdlib/assert/is-between-array",isBetweenArray
+"@stdlib/assert/is-binary-string",isBinaryString
+"@stdlib/assert/is-boolean",isBoolean
+"@stdlib/assert/is-boolean-array",isBooleanArray
+"@stdlib/assert/is-boxed-primitive",isBoxedPrimitive
+"@stdlib/assert/is-buffer",isBuffer
+"@stdlib/assert/is-capitalized",isCapitalized
+"@stdlib/assert/is-centrosymmetric-matrix",isCentrosymmetricMatrix
+"@stdlib/assert/is-circular",isCircular
+"@stdlib/assert/is-circular-array",isCircularArray
+"@stdlib/assert/is-circular-plain-object",isCircularPlainObject
+"@stdlib/assert/is-collection",isCollection
+"@stdlib/assert/is-complex",isComplex
+"@stdlib/assert/is-complex64",isComplex64
+"@stdlib/assert/is-complex64array",isComplex64Array
+"@stdlib/assert/is-complex128",isComplex128
+"@stdlib/assert/is-complex128array",isComplex128Array
+"@stdlib/assert/is-complex-like",isComplexLike
+"@stdlib/assert/is-complex-typed-array",isComplexTypedArray
+"@stdlib/assert/is-configurable-property",isConfigurableProperty
+"@stdlib/assert/is-configurable-property-in",isConfigurablePropertyIn
+"@stdlib/assert/is-data-property",isDataProperty
+"@stdlib/assert/is-data-property-in",isDataPropertyIn
+"@stdlib/assert/is-date-object",isDateObject
+"@stdlib/assert/is-digit-string",isDigitString
+"@stdlib/assert/is-email-address",isEmailAddress
+"@stdlib/assert/is-empty-array",isEmptyArray
+"@stdlib/assert/is-empty-object",isEmptyObject
+"@stdlib/assert/is-empty-string",isEmptyString
+"@stdlib/assert/is-enumerable-property",isEnumerableProperty
+"@stdlib/assert/is-enumerable-property-in",isEnumerablePropertyIn
+"@stdlib/assert/is-error",isError
+"@stdlib/assert/is-eval-error",isEvalError
+"@stdlib/assert/is-even",isEven
+"@stdlib/assert/is-falsy",isFalsy
+"@stdlib/assert/is-falsy-array",isFalsyArray
+"@stdlib/assert/is-finite",isFinite
+"@stdlib/assert/is-finite-array",isFiniteArray
+"@stdlib/assert/is-float32array",isFloat32Array
+"@stdlib/assert/is-float64array",isFloat64Array
+"@stdlib/assert/is-function",isFunction
+"@stdlib/assert/is-function-array",isFunctionArray
+"@stdlib/assert/is-generator-object",isGeneratorObject
+"@stdlib/assert/is-generator-object-like",isGeneratorObjectLike
+"@stdlib/assert/is-hex-string",isHexString
+"@stdlib/assert/is-infinite",isInfinite
+"@stdlib/assert/is-inherited-property",isInheritedProperty
+"@stdlib/assert/is-int8array",isInt8Array
+"@stdlib/assert/is-int16array",isInt16Array
+"@stdlib/assert/is-int32array",isInt32Array
+"@stdlib/assert/is-integer",isInteger
+"@stdlib/assert/is-integer-array",isIntegerArray
+"@stdlib/assert/is-iterable-like",isIterableLike
+"@stdlib/assert/is-iterator-like",isIteratorLike
+"@stdlib/assert/is-json",isJSON
+"@stdlib/assert/is-leap-year",isLeapYear
+"@stdlib/assert/is-lowercase",isLowercase
+"@stdlib/assert/is-matrix-like",isMatrixLike
+"@stdlib/assert/is-method",isMethod
+"@stdlib/assert/is-method-in",isMethodIn
+"@stdlib/assert/is-named-typed-tuple-like",isNamedTypedTupleLike
+"@stdlib/assert/is-nan",isnan
+"@stdlib/assert/is-nan-array",isNaNArray
+"@stdlib/assert/is-native-function",isNativeFunction
+"@stdlib/assert/is-ndarray-like",isndarrayLike
+"@stdlib/assert/is-negative-integer",isNegativeInteger
+"@stdlib/assert/is-negative-integer-array",isNegativeIntegerArray
+"@stdlib/assert/is-negative-number",isNegativeNumber
+"@stdlib/assert/is-negative-number-array",isNegativeNumberArray
+"@stdlib/assert/is-negative-zero",isNegativeZero
+"@stdlib/assert/is-node-builtin",isNodeBuiltin
+"@stdlib/assert/is-node-duplex-stream-like",isNodeDuplexStreamLike
+"@stdlib/assert/is-node-readable-stream-like",isNodeReadableStreamLike
+"@stdlib/assert/is-node-repl",isNodeREPL
+"@stdlib/assert/is-node-stream-like",isNodeStreamLike
+"@stdlib/assert/is-node-transform-stream-like",isNodeTransformStreamLike
+"@stdlib/assert/is-node-writable-stream-like",isNodeWritableStreamLike
+"@stdlib/assert/is-nonconfigurable-property",isNonConfigurableProperty
+"@stdlib/assert/is-nonconfigurable-property-in",isNonConfigurablePropertyIn
+"@stdlib/assert/is-nonenumerable-property",isNonEnumerableProperty
+"@stdlib/assert/is-nonenumerable-property-in",isNonEnumerablePropertyIn
+"@stdlib/assert/is-nonnegative-integer",isNonNegativeInteger
+"@stdlib/assert/is-nonnegative-integer-array",isNonNegativeIntegerArray
+"@stdlib/assert/is-nonnegative-number",isNonNegativeNumber
+"@stdlib/assert/is-nonnegative-number-array",isNonNegativeNumberArray
+"@stdlib/assert/is-nonpositive-integer",isNonPositiveInteger
+"@stdlib/assert/is-nonpositive-integer-array",isNonPositiveIntegerArray
+"@stdlib/assert/is-nonpositive-number",isNonPositiveNumber
+"@stdlib/assert/is-nonpositive-number-array",isNonPositiveNumberArray
+"@stdlib/assert/is-nonsymmetric-matrix",isNonSymmetricMatrix
+"@stdlib/assert/is-null",isNull
+"@stdlib/assert/is-null-array",isNullArray
+"@stdlib/assert/is-number",isNumber
+"@stdlib/assert/is-number-array",isNumberArray
+"@stdlib/assert/is-numeric-array",isNumericArray
+"@stdlib/assert/is-object",isObject
+"@stdlib/assert/is-object-array",isObjectArray
+"@stdlib/assert/is-object-like",isObjectLike
+"@stdlib/assert/is-odd",isOdd
+"@stdlib/time/iso-weeks-in-year",isoWeeksInYear
+"@stdlib/assert/is-persymmetric-matrix",isPersymmetricMatrix
+"@stdlib/assert/is-plain-object",isPlainObject
+"@stdlib/assert/is-plain-object-array",isPlainObjectArray
+"@stdlib/assert/is-positive-integer",isPositiveInteger
+"@stdlib/assert/is-positive-integer-array",isPositiveIntegerArray
+"@stdlib/assert/is-positive-number",isPositiveNumber
+"@stdlib/assert/is-positive-number-array",isPositiveNumberArray
+"@stdlib/assert/is-positive-zero",isPositiveZero
+"@stdlib/assert/is-primitive",isPrimitive
+"@stdlib/assert/is-primitive-array",isPrimitiveArray
+"@stdlib/assert/is-prng-like",isPRNGLike
+"@stdlib/assert/is-probability",isProbability
+"@stdlib/assert/is-probability-array",isProbabilityArray
+"@stdlib/assert/is-prototype-of",isPrototypeOf
+"@stdlib/assert/is-range-error",isRangeError
+"@stdlib/assert/is-readable-property",isReadableProperty
+"@stdlib/assert/is-readable-property-in",isReadablePropertyIn
+"@stdlib/assert/is-read-only-property",isReadOnlyProperty
+"@stdlib/assert/is-read-only-property-in",isReadOnlyPropertyIn
+"@stdlib/assert/is-read-write-property",isReadWriteProperty
+"@stdlib/assert/is-read-write-property-in",isReadWritePropertyIn
+"@stdlib/assert/is-reference-error",isReferenceError
+"@stdlib/assert/is-regexp",isRegExp
+"@stdlib/assert/is-regexp-string",isRegExpString
+"@stdlib/assert/is-relative-path",isRelativePath
+"@stdlib/assert/is-safe-integer",isSafeInteger
+"@stdlib/assert/is-safe-integer-array",isSafeIntegerArray
+"@stdlib/assert/is-same-value",isSameValue
+"@stdlib/assert/is-same-value-zero",isSameValueZero
+"@stdlib/assert/is-sharedarraybuffer",isSharedArrayBuffer
+"@stdlib/assert/is-skew-centrosymmetric-matrix",isSkewCentrosymmetricMatrix
+"@stdlib/assert/is-skew-persymmetric-matrix",isSkewPersymmetricMatrix
+"@stdlib/assert/is-skew-symmetric-matrix",isSkewSymmetricMatrix
+"@stdlib/assert/is-square-matrix",isSquareMatrix
+"@stdlib/assert/is-strict-equal",isStrictEqual
+"@stdlib/assert/is-string",isString
+"@stdlib/assert/is-string-array",isStringArray
+"@stdlib/assert/is-symbol",isSymbol
+"@stdlib/assert/is-symbol-array",isSymbolArray
+"@stdlib/assert/is-symmetric-matrix",isSymmetricMatrix
+"@stdlib/assert/is-syntax-error",isSyntaxError
+"@stdlib/assert/is-truthy",isTruthy
+"@stdlib/assert/is-truthy-array",isTruthyArray
+"@stdlib/assert/is-typed-array",isTypedArray
+"@stdlib/assert/is-typed-array-length",isTypedArrayLength
+"@stdlib/assert/is-typed-array-like",isTypedArrayLike
+"@stdlib/assert/is-type-error",isTypeError
+"@stdlib/assert/is-uint8array",isUint8Array
+"@stdlib/assert/is-uint8clampedarray",isUint8ClampedArray
+"@stdlib/assert/is-uint16array",isUint16Array
+"@stdlib/assert/is-uint32array",isUint32Array
+"@stdlib/assert/is-unc-path",isUNCPath
+"@stdlib/assert/is-undefined",isUndefined
+"@stdlib/assert/is-undefined-or-null",isUndefinedOrNull
+"@stdlib/assert/is-unity-probability-array",isUnityProbabilityArray
+"@stdlib/assert/is-uppercase",isUppercase
+"@stdlib/assert/is-uri",isURI
+"@stdlib/assert/is-uri-error",isURIError
+"@stdlib/assert/is-vector-like",isVectorLike
+"@stdlib/assert/is-whitespace",isWhitespace
+"@stdlib/assert/is-writable-property",isWritableProperty
+"@stdlib/assert/is-writable-property-in",isWritablePropertyIn
+"@stdlib/assert/is-write-only-property",isWriteOnlyProperty
+"@stdlib/assert/is-write-only-property-in",isWriteOnlyPropertyIn
+"@stdlib/math/iter/add",iterAdd
+"@stdlib/iter/advance",iterAdvance
+"@stdlib/iter/any",iterAny
+"@stdlib/iter/any-by",iterAnyBy
+"@stdlib/array/from-iterator",iterator2array
+"@stdlib/iter/to-array-view",iterator2arrayview
+"@stdlib/iter/to-array-view-right",iterator2arrayviewRight
+"@stdlib/streams/node/from-iterator",iteratorStream
+"@stdlib/symbol/iterator",IteratorSymbol
+"@stdlib/simulate/iter/awgn",iterawgn
+"@stdlib/simulate/iter/awln",iterawln
+"@stdlib/simulate/iter/awun",iterawun
+"@stdlib/simulate/iter/bartlett-hann-pulse",iterBartlettHannPulse
+"@stdlib/simulate/iter/bartlett-pulse",iterBartlettPulse
+"@stdlib/iter/concat",iterConcat
+"@stdlib/iter/constant",iterConstant
+"@stdlib/simulate/iter/cosine-wave",iterCosineWave
+"@stdlib/iter/counter",iterCounter
+"@stdlib/stats/iter/cugmean",itercugmean
+"@stdlib/stats/iter/cuhmean",itercuhmean
+"@stdlib/stats/iter/cumax",itercumax
+"@stdlib/stats/iter/cumaxabs",itercumaxabs
+"@stdlib/stats/iter/cumean",itercumean
+"@stdlib/stats/iter/cumeanabs",itercumeanabs
+"@stdlib/stats/iter/cumeanabs2",itercumeanabs2
+"@stdlib/stats/iter/cumidrange",itercumidrange
+"@stdlib/stats/iter/cumin",itercumin
+"@stdlib/stats/iter/cuminabs",itercuminabs
+"@stdlib/stats/iter/cuprod",itercuprod
+"@stdlib/stats/iter/curange",itercurange
+"@stdlib/stats/iter/cusum",itercusum
+"@stdlib/stats/iter/cusumabs",itercusumabs
+"@stdlib/stats/iter/cusumabs2",itercusumabs2
+"@stdlib/iter/dedupe",iterDedupe
+"@stdlib/iter/dedupe-by",iterDedupeBy
+"@stdlib/simulate/iter/dirac-comb",iterDiracComb
+"@stdlib/math/iter/divide",iterDivide
+"@stdlib/iter/empty",iterEmpty
+"@stdlib/iter/every",iterEvery
+"@stdlib/iter/every-by",iterEveryBy
+"@stdlib/math/iter/fibonacci",iterFibonacci
+"@stdlib/iter/fill",iterFill
+"@stdlib/iter/filter",iterFilter
+"@stdlib/iter/filter-map",iterFilterMap
+"@stdlib/iter/first",iterFirst
+"@stdlib/simulate/iter/flat-top-pulse",iterFlatTopPulse
+"@stdlib/iter/flow",iterFlow
+"@stdlib/iter/for-each",iterForEach
+"@stdlib/simulate/iter/hann-pulse",iterHannPulse
+"@stdlib/iter/head",iterHead
+"@stdlib/iter/intersection",iterIntersection
+"@stdlib/iter/intersection-by-hash",iterIntersectionByHash
+"@stdlib/simulate/iter/lanczos-pulse",iterLanczosPulse
+"@stdlib/iter/last",iterLast
+"@stdlib/iter/length",iterLength
+"@stdlib/iter/map",iterMap
+"@stdlib/iter/mapn",iterMapN
+"@stdlib/stats/iter/max",itermax
+"@stdlib/stats/iter/maxabs",itermaxabs
+"@stdlib/stats/iter/mean",itermean
+"@stdlib/stats/iter/meanabs",itermeanabs
+"@stdlib/stats/iter/meanabs2",itermeanabs2
+"@stdlib/stats/iter/midrange",itermidrange
+"@stdlib/stats/iter/min",itermin
+"@stdlib/stats/iter/minabs",iterminabs
+"@stdlib/stats/iter/mmax",itermmax
+"@stdlib/stats/iter/mmaxabs",itermmaxabs
+"@stdlib/stats/iter/mmean",itermmean
+"@stdlib/stats/iter/mmeanabs",itermmeanabs
+"@stdlib/stats/iter/mmeanabs2",itermmeanabs2
+"@stdlib/stats/iter/mmidrange",itermmidrange
+"@stdlib/stats/iter/mmin",itermmin
+"@stdlib/stats/iter/mminabs",itermminabs
+"@stdlib/math/iter/mod",iterMod
+"@stdlib/stats/iter/mprod",itermprod
+"@stdlib/stats/iter/mrange",itermrange
+"@stdlib/stats/iter/msum",itermsum
+"@stdlib/stats/iter/msumabs",itermsumabs
+"@stdlib/stats/iter/msumabs2",itermsumabs2
+"@stdlib/math/iter/multiply",iterMultiply
+"@stdlib/iter/none",iterNone
+"@stdlib/iter/none-by",iterNoneBy
+"@stdlib/math/iter/nonfibonacci",iterNonFibonacci
+"@stdlib/iter/nth",iterNth
+"@stdlib/simulate/iter/periodic-sinc",iterPeriodicSinc
+"@stdlib/iter/pipeline",iterPipeline
+"@stdlib/iter/pop",iterPop
+"@stdlib/stats/iter/prod",iterprod
+"@stdlib/simulate/iter/pulse",iterPulse
+"@stdlib/iter/push",iterPush
+"@stdlib/stats/iter/range",iterrange
+"@stdlib/iter/reject",iterReject
+"@stdlib/iter/replicate",iterReplicate
+"@stdlib/iter/replicate-by",iterReplicateBy
+"@stdlib/simulate/iter/sawtooth-wave",iterSawtoothWave
+"@stdlib/iter/shift",iterShift
+"@stdlib/simulate/iter/sine-wave",iterSineWave
+"@stdlib/iter/slice",iterSlice
+"@stdlib/iter/some",iterSome
+"@stdlib/iter/some-by",iterSomeBy
+"@stdlib/simulate/iter/square-wave",iterSquareWave
+"@stdlib/stats/iter/stdev",iterstdev
+"@stdlib/math/iter/subtract",iterSubtract
+"@stdlib/stats/iter/sum",itersum
+"@stdlib/stats/iter/sumabs",itersumabs
+"@stdlib/stats/iter/sumabs2",itersumabs2
+"@stdlib/iter/pipeline-thunk",iterThunk
+"@stdlib/simulate/iter/triangle-wave",iterTriangleWave
+"@stdlib/iter/union",iterUnion
+"@stdlib/iter/unique",iterUnique
+"@stdlib/iter/unique-by",iterUniqueBy
+"@stdlib/iter/unique-by-hash",iterUniqueByHash
+"@stdlib/iter/unshift",iterUnshift
+"@stdlib/stats/iter/variance",itervariance
+"@stdlib/streams/node/join",joinStream
+"@stdlib/stats/kde2d",kde2d
+"@stdlib/utils/key-by",keyBy
+"@stdlib/utils/key-by-right",keyByRight
+"@stdlib/utils/keys-in",keysIn
+"@stdlib/stats/kruskal-test",kruskalTest
+"@stdlib/stats/kstest",kstest
+"@stdlib/nlp/lda",lda
+"@stdlib/utils/linked-list",LinkedList
+"@stdlib/math/utils/linspace",linspace
+"@stdlib/datasets/liu-negative-opinion-words-en",LIU_NEGATIVE_OPINION_WORDS_EN
+"@stdlib/datasets/liu-positive-opinion-words-en",LIU_POSITIVE_OPINION_WORDS_EN
+"@stdlib/constants/math/float64-ln-half",LN_HALF
+"@stdlib/constants/math/float64-ln-pi",LN_PI
+"@stdlib/constants/math/float64-ln-sqrt-two-pi",LN_SQRT_TWO_PI
+"@stdlib/constants/math/float64-ln-two-pi",LN_TWO_PI
+"@stdlib/constants/math/float64-ln-two",LN2
+"@stdlib/constants/math/float64-ln-ten",LN10
+"@stdlib/constants/math/float64-log2-e",LOG2E
+"@stdlib/constants/math/float64-log10-e",LOG10E
+"@stdlib/math/utils/logspace",logspace
+"@stdlib/string/lowercase",lowercase
+"@stdlib/utils/lowercase-keys",lowercaseKeys
+"@stdlib/stats/lowess",lowess
+"@stdlib/string/left-pad",lpad
+"@stdlib/string/left-trim",ltrim
+"@stdlib/datasets/male-first-names-en",MALE_FIRST_NAMES_EN
+"@stdlib/utils/map-function",mapFun
+"@stdlib/utils/async/map-function",mapFunAsync
+"@stdlib/utils/map-keys",mapKeys
+"@stdlib/utils/async/map-keys",mapKeysAsync
+"@stdlib/utils/map-values",mapValues
+"@stdlib/utils/async/map-values",mapValuesAsync
+"@stdlib/constants/array/max-array-length",MAX_ARRAY_LENGTH
+"@stdlib/constants/array/max-typed-array-length",MAX_TYPED_ARRAY_LENGTH
+"@stdlib/utils/memoize",memoize
+"@stdlib/utils/merge",merge
+"@stdlib/constants/time/milliseconds-in-day",MILLISECONDS_IN_DAY
+"@stdlib/constants/time/milliseconds-in-hour",MILLISECONDS_IN_HOUR
+"@stdlib/constants/time/milliseconds-in-minute",MILLISECONDS_IN_MINUTE
+"@stdlib/constants/time/milliseconds-in-second",MILLISECONDS_IN_SECOND
+"@stdlib/constants/time/milliseconds-in-week",MILLISECONDS_IN_WEEK
+"@stdlib/datasets/minard-napoleons-march",MINARD_NAPOLEONS_MARCH
+"@stdlib/constants/time/minutes-in-day",MINUTES_IN_DAY
+"@stdlib/constants/time/minutes-in-hour",MINUTES_IN_HOUR
+"@stdlib/constants/time/minutes-in-week",MINUTES_IN_WEEK
+"@stdlib/time/minutes-in-month",minutesInMonth
+"@stdlib/time/minutes-in-year",minutesInYear
+"@stdlib/datasets/moby-dick",MOBY_DICK
+"@stdlib/datasets/month-names-en",MONTH_NAMES_EN
+"@stdlib/constants/time/months-in-year",MONTHS_IN_YEAR
+"@stdlib/utils/move-property",moveProperty
+"@stdlib/utils/named-typed-tuple",namedtypedtuple
+"@stdlib/utils/native-class",nativeClass
+"@stdlib/ndarray/ctor",ndarray
+"@stdlib/ndarray/casting-modes",ndarrayCastingModes
+"@stdlib/ndarray/dtypes",ndarrayDataTypes
+"@stdlib/ndarray/index-modes",ndarrayIndexModes
+"@stdlib/ndarray/memoized-ctor",ndarrayMemoized
+"@stdlib/ndarray/min-dtype",ndarrayMinDataType
+"@stdlib/ndarray/next-dtype",ndarrayNextDataType
+"@stdlib/ndarray/orders",ndarrayOrders
+"@stdlib/ndarray/promotion-rules",ndarrayPromotionRules
+"@stdlib/ndarray/safe-casts",ndarraySafeCasts
+"@stdlib/ndarray/same-kind-casts",ndarraySameKindCasts
+"@stdlib/datasets/nightingales-rose",NIGHTINGALES_ROSE
+"@stdlib/constants/math/float64-ninf",NINF
+"@stdlib/process/node-version",NODE_VERSION
+"@stdlib/utils/none",none
+"@stdlib/utils/none-by",noneBy
+"@stdlib/utils/async/none-by",noneByAsync
+"@stdlib/utils/none-by-right",noneByRight
+"@stdlib/utils/async/none-by-right",noneByRightAsync
+"@stdlib/utils/nonenumerable-properties",nonEnumerableProperties
+"@stdlib/utils/nonenumerable-properties-in",nonEnumerablePropertiesIn
+"@stdlib/utils/nonenumerable-property-names",nonEnumerablePropertyNames
+"@stdlib/utils/nonenumerable-property-names-in",nonEnumerablePropertyNamesIn
+"@stdlib/utils/nonenumerable-property-symbols",nonEnumerablePropertySymbols
+"@stdlib/utils/nonenumerable-property-symbols-in",nonEnumerablePropertySymbolsIn
+"@stdlib/utils/noop",noop
+"@stdlib/time/now",now
+"@stdlib/os/num-cpus",NUM_CPUS
+"@stdlib/number/ctor",Number
+"@stdlib/utils/entries",objectEntries
+"@stdlib/utils/entries-in",objectEntriesIn
+"@stdlib/utils/from-entries",objectFromEntries
+"@stdlib/utils/object-inverse",objectInverse
+"@stdlib/utils/object-inverse-by",objectInverseBy
+"@stdlib/utils/keys",objectKeys
+"@stdlib/utils/values",objectValues
+"@stdlib/utils/values-in",objectValuesIn
+"@stdlib/utils/omit",omit
+"@stdlib/utils/omit-by",omitBy
+"@stdlib/ml/online-binary-classification",onlineBinaryClassification
+"@stdlib/ml/online-sgd-regression",onlineSGDRegression
+"@stdlib/utils/open-url",openURL
+"@stdlib/datasets/pace-boston-house-prices",PACE_BOSTON_HOUSE_PRICES
+"@stdlib/string/pad",pad
+"@stdlib/utils/papply",papply
+"@stdlib/utils/papply-right",papplyRight
+"@stdlib/utils/parallel",parallel
+"@stdlib/utils/parse-json",parseJSON
+"@stdlib/constants/string/path-delimiter",PATH_DELIMITER
+"@stdlib/constants/string/path-delimiter-posix",PATH_DELIMITER_POSIX
+"@stdlib/constants/string/path-delimiter-win32",PATH_DELIMITER_WIN32
+"@stdlib/constants/string/path-sep",PATH_SEP
+"@stdlib/constants/string/path-sep-posix",PATH_SEP_POSIX
+"@stdlib/constants/string/path-sep-win32",PATH_SEP_WIN32
+"@stdlib/stats/pcorrtest",pcorrtest
+"@stdlib/string/percent-encode",percentEncode
+"@stdlib/constants/math/float64-phi",PHI
+"@stdlib/constants/math/float64-pi",PI
+"@stdlib/constants/math/float64-pi-squared",PI_SQUARED
+"@stdlib/utils/pick",pick
+"@stdlib/utils/pick-by",pickBy
+"@stdlib/constants/math/float64-pinf",PINF
+"@stdlib/namespace/pkg2alias",pkg2alias
+"@stdlib/namespace/pkg2related",pkg2related
+"@stdlib/os/platform",PLATFORM
+"@stdlib/plot",plot
+"@stdlib/plot/ctor",Plot
+"@stdlib/utils/pluck",pluck
+"@stdlib/utils/pop",pop
+"@stdlib/utils/prepend",prepend
+"@stdlib/utils/properties",properties
+"@stdlib/utils/properties-in",propertiesIn
+"@stdlib/utils/property-descriptor",propertyDescriptor
+"@stdlib/utils/property-descriptor-in",propertyDescriptorIn
+"@stdlib/utils/property-descriptors",propertyDescriptors
+"@stdlib/utils/property-descriptors-in",propertyDescriptorsIn
+"@stdlib/utils/property-names",propertyNames
+"@stdlib/utils/property-names-in",propertyNamesIn
+"@stdlib/utils/property-symbols",propertySymbols
+"@stdlib/utils/property-symbols-in",propertySymbolsIn
+"@stdlib/proxy/ctor",Proxy
+"@stdlib/utils/push",push
+"@stdlib/time/quarter-of-year",quarterOfYear
+"@stdlib/random/iter/arcsine",random.iterators.arcsine
+"@stdlib/random/iter/bernoulli",random.iterators.bernoulli
+"@stdlib/random/iter/beta",random.iterators.beta
+"@stdlib/random/iter/betaprime",random.iterators.betaprime
+"@stdlib/random/iter/binomial",random.iterators.binomial
+"@stdlib/random/iter/box-muller",random.iterators.boxMuller
+"@stdlib/random/iter/cauchy",random.iterators.cauchy
+"@stdlib/random/iter/chi",random.iterators.chi
+"@stdlib/random/iter/chisquare",random.iterators.chisquare
+"@stdlib/random/iter/cosine",random.iterators.cosine
+"@stdlib/random/iter/discrete-uniform",random.iterators.discreteUniform
+"@stdlib/random/iter/erlang",random.iterators.erlang
+"@stdlib/random/iter/exponential",random.iterators.exponential
+"@stdlib/random/iter/f",random.iterators.f
+"@stdlib/random/iter/frechet",random.iterators.frechet
+"@stdlib/random/iter/gamma",random.iterators.gamma
+"@stdlib/random/iter/geometric",random.iterators.geometric
+"@stdlib/random/iter/gumbel",random.iterators.gumbel
+"@stdlib/random/iter/hypergeometric",random.iterators.hypergeometric
+"@stdlib/random/iter/improved-ziggurat",random.iterators.improvedZiggurat
+"@stdlib/random/iter/invgamma",random.iterators.invgamma
+"@stdlib/random/iter/kumaraswamy",random.iterators.kumaraswamy
+"@stdlib/random/iter/laplace",random.iterators.laplace
+"@stdlib/random/iter/levy",random.iterators.levy
+"@stdlib/random/iter/logistic",random.iterators.logistic
+"@stdlib/random/iter/lognormal",random.iterators.lognormal
+"@stdlib/random/iter/minstd",random.iterators.minstd
+"@stdlib/random/iter/minstd-shuffle",random.iterators.minstdShuffle
+"@stdlib/random/iter/mt19937",random.iterators.mt19937
+"@stdlib/random/iter/negative-binomial",random.iterators.negativeBinomial
+"@stdlib/random/iter/normal",random.iterators.normal
+"@stdlib/random/iter/pareto-type1",random.iterators.pareto1
+"@stdlib/random/iter/poisson",random.iterators.poisson
+"@stdlib/random/iter/randi",random.iterators.randi
+"@stdlib/random/iter/randn",random.iterators.randn
+"@stdlib/random/iter/randu",random.iterators.randu
+"@stdlib/random/iter/rayleigh",random.iterators.rayleigh
+"@stdlib/random/iter/t",random.iterators.t
+"@stdlib/random/iter/triangular",random.iterators.triangular
+"@stdlib/random/iter/uniform",random.iterators.uniform
+"@stdlib/random/iter/weibull",random.iterators.weibull
+"@stdlib/random/streams/arcsine",random.streams.arcsine
+"@stdlib/random/streams/bernoulli",random.streams.bernoulli
+"@stdlib/random/streams/beta",random.streams.beta
+"@stdlib/random/streams/betaprime",random.streams.betaprime
+"@stdlib/random/streams/binomial",random.streams.binomial
+"@stdlib/random/streams/box-muller",random.streams.boxMuller
+"@stdlib/random/streams/cauchy",random.streams.cauchy
+"@stdlib/random/streams/chi",random.streams.chi
+"@stdlib/random/streams/chisquare",random.streams.chisquare
+"@stdlib/random/streams/cosine",random.streams.cosine
+"@stdlib/random/streams/discrete-uniform",random.streams.discreteUniform
+"@stdlib/random/streams/erlang",random.streams.erlang
+"@stdlib/random/streams/exponential",random.streams.exponential
+"@stdlib/random/streams/f",random.streams.f
+"@stdlib/random/streams/gamma",random.streams.gamma
+"@stdlib/random/streams/geometric",random.streams.geometric
+"@stdlib/random/streams/gumbel",random.streams.gumbel
+"@stdlib/random/streams/improved-ziggurat",random.streams.improvedZiggurat
+"@stdlib/random/streams/invgamma",random.streams.invgamma
+"@stdlib/random/streams/kumaraswamy",random.streams.kumaraswamy
+"@stdlib/random/streams/laplace",random.streams.laplace
+"@stdlib/random/streams/levy",random.streams.levy
+"@stdlib/random/streams/logistic",random.streams.logistic
+"@stdlib/random/streams/lognormal",random.streams.lognormal
+"@stdlib/random/streams/minstd",random.streams.minstd
+"@stdlib/random/streams/minstd-shuffle",random.streams.minstdShuffle
+"@stdlib/random/streams/mt19937",random.streams.mt19937
+"@stdlib/random/streams/negative-binomial",random.streams.negativeBinomial
+"@stdlib/random/streams/normal",random.streams.normal
+"@stdlib/random/streams/pareto-type1",random.streams.pareto1
+"@stdlib/random/streams/poisson",random.streams.poisson
+"@stdlib/random/streams/randi",random.streams.randi
+"@stdlib/random/streams/randn",random.streams.randn
+"@stdlib/random/streams/randu",random.streams.randu
+"@stdlib/random/streams/rayleigh",random.streams.rayleigh
+"@stdlib/random/streams/t",random.streams.t
+"@stdlib/random/streams/uniform",random.streams.uniform
+"@stdlib/random/streams/weibull",random.streams.weibull
+"@stdlib/stats/ranks",ranks
+"@stdlib/regexp/basename",RE_BASENAME
+"@stdlib/regexp/basename-posix",RE_BASENAME_POSIX
+"@stdlib/regexp/basename-windows",RE_BASENAME_WINDOWS
+"@stdlib/regexp/color-hexadecimal",RE_COLOR_HEXADECIMAL
+"@stdlib/regexp/decimal-number",RE_DECIMAL_NUMBER
+"@stdlib/regexp/dirname",RE_DIRNAME
+"@stdlib/regexp/dirname-posix",RE_DIRNAME_POSIX
+"@stdlib/regexp/dirname-windows",RE_DIRNAME_WINDOWS
+"@stdlib/regexp/eol",RE_EOL
+"@stdlib/regexp/extended-length-path",RE_EXTENDED_LENGTH_PATH
+"@stdlib/regexp/extname",RE_EXTNAME
+"@stdlib/regexp/extname-posix",RE_EXTNAME_POSIX
+"@stdlib/regexp/extname-windows",RE_EXTNAME_WINDOWS
+"@stdlib/regexp/filename",RE_FILENAME
+"@stdlib/regexp/filename-posix",RE_FILENAME_POSIX
+"@stdlib/regexp/filename-windows",RE_FILENAME_WINDOWS
+"@stdlib/regexp/function-name",RE_FUNCTION_NAME
+"@stdlib/regexp/native-function",RE_NATIVE_FUNCTION
+"@stdlib/regexp/regexp",RE_REGEXP
+"@stdlib/regexp/unc-path",RE_UNC_PATH
+"@stdlib/regexp/utf16-surrogate-pair",RE_UTF16_SURROGATE_PAIR
+"@stdlib/regexp/utf16-unpaired-surrogate",RE_UTF16_UNPAIRED_SURROGATE
+"@stdlib/regexp/whitespace",RE_WHITESPACE
+"@stdlib/fs/read-dir",readDir
+"@stdlib/fs/read-file",readFile
+"@stdlib/fs/read-file-list",readFileList
+"@stdlib/fs/read-json",readJSON
+"@stdlib/fs/read-wasm",readWASM
+"@stdlib/complex/real",real
+"@stdlib/utils/real-max",realmax
+"@stdlib/utils/real-min",realmin
+"@stdlib/utils/reduce",reduce
+"@stdlib/utils/async/reduce",reduceAsync
+"@stdlib/utils/reduce-right",reduceRight
+"@stdlib/utils/async/reduce-right",reduceRightAsync
+"@stdlib/utils/regexp-from-string",reFromString
+"@stdlib/complex/reim",reim
+"@stdlib/string/remove-first",removeFirst
+"@stdlib/string/remove-last",removeLast
+"@stdlib/string/remove-punctuation",removePunctuation
+"@stdlib/string/remove-utf8-bom",removeUTF8BOM
+"@stdlib/string/remove-words",removeWords
+"@stdlib/fs/rename",rename
+"@stdlib/utils/reorder-arguments",reorderArguments
+"@stdlib/string/repeat",repeat
+"@stdlib/string/replace",replace
+"@stdlib/utils/escape-regexp-string",rescape
+"@stdlib/fs/resolve-parent-path",resolveParentPath
+"@stdlib/utils/reverse-arguments",reverseArguments
+"@stdlib/string/reverse",reverseString
+"@stdlib/random/base/reviver",reviveBasePRNG
+"@stdlib/buffer/reviver",reviveBuffer
+"@stdlib/complex/reviver",reviveComplex
+"@stdlib/complex/reviver-float32",reviveComplex64
+"@stdlib/complex/reviver-float64",reviveComplex128
+"@stdlib/error/reviver",reviveError
+"@stdlib/array/reviver",reviveTypedArray
+"@stdlib/string/right-pad",rpad
+"@stdlib/string/right-trim",rtrim
+"@stdlib/utils/safe-int-max",safeintmax
+"@stdlib/utils/safe-int-min",safeintmin
+"@stdlib/random/sample",sample
+"@stdlib/datasets/savoy-stopwords-fin",SAVOY_STOPWORDS_FIN
+"@stdlib/datasets/savoy-stopwords-fr",SAVOY_STOPWORDS_FR
+"@stdlib/datasets/savoy-stopwords-ger",SAVOY_STOPWORDS_GER
+"@stdlib/datasets/savoy-stopwords-it",SAVOY_STOPWORDS_IT
+"@stdlib/datasets/savoy-stopwords-por",SAVOY_STOPWORDS_POR
+"@stdlib/datasets/savoy-stopwords-sp",SAVOY_STOPWORDS_SP
+"@stdlib/datasets/savoy-stopwords-swe",SAVOY_STOPWORDS_SWE
+"@stdlib/constants/time/seconds-in-day",SECONDS_IN_DAY
+"@stdlib/constants/time/seconds-in-hour",SECONDS_IN_HOUR
+"@stdlib/constants/time/seconds-in-minute",SECONDS_IN_MINUTE
+"@stdlib/constants/time/seconds-in-week",SECONDS_IN_WEEK
+"@stdlib/time/seconds-in-month",secondsInMonth
+"@stdlib/time/seconds-in-year",secondsInYear
+"@stdlib/utils/define-configurable-read-only-property",setConfigurableReadOnly
+"@stdlib/utils/define-configurable-read-only-accessor",setConfigurableReadOnlyAccessor
+"@stdlib/utils/define-configurable-read-write-accessor",setConfigurableReadWriteAccessor
+"@stdlib/utils/define-configurable-write-only-accessor",setConfigurableWriteOnlyAccessor
+"@stdlib/utils/define-memoized-read-only-property",setMemoizedReadOnly
+"@stdlib/utils/define-nonenumerable-property",setNonEnumerableProperty
+"@stdlib/utils/define-nonenumerable-read-only-property",setNonEnumerableReadOnly
+"@stdlib/utils/define-nonenumerable-read-only-accessor",setNonEnumerableReadOnlyAccessor
+"@stdlib/utils/define-nonenumerable-read-write-accessor",setNonEnumerableReadWriteAccessor
+"@stdlib/utils/define-nonenumerable-write-only-accessor",setNonEnumerableWriteOnlyAccessor
+"@stdlib/utils/define-read-only-property",setReadOnly
+"@stdlib/utils/define-read-only-accessor",setReadOnlyAccessor
+"@stdlib/utils/define-read-write-accessor",setReadWriteAccessor
+"@stdlib/utils/define-write-only-accessor",setWriteOnlyAccessor
+"@stdlib/array/shared-buffer",SharedArrayBuffer
+"@stdlib/utils/shift",shift
+"@stdlib/random/shuffle",shuffle
+"@stdlib/utils/size-of",sizeOf
+"@stdlib/utils/some",some
+"@stdlib/utils/some-by",someBy
+"@stdlib/utils/async/some-by",someByAsync
+"@stdlib/utils/some-by-right",someByRight
+"@stdlib/utils/async/some-by-right",someByRightAsync
+"@stdlib/datasets/sotu",SOTU
+"@stdlib/datasets/spache-revised",SPACHE_REVISED
+"@stdlib/datasets/spam-assassin",SPAM_ASSASSIN
+"@stdlib/plot/sparklines/base/ctor",SparklineBase
+"@stdlib/array/to-sparse-iterator",sparsearray2iterator
+"@stdlib/array/to-sparse-iterator-right",sparsearray2iteratorRight
+"@stdlib/streams/node/split",splitStream
+"@stdlib/constants/math/float64-sqrt-eps",SQRT_EPS
+"@stdlib/constants/math/float64-sqrt-half",SQRT_HALF
+"@stdlib/constants/math/float64-sqrt-half-pi",SQRT_HALF_PI
+"@stdlib/constants/math/float64-sqrt-phi",SQRT_PHI
+"@stdlib/constants/math/float64-sqrt-pi",SQRT_PI
+"@stdlib/constants/math/float64-sqrt-three",SQRT_THREE
+"@stdlib/constants/math/float64-sqrt-two",SQRT_TWO
+"@stdlib/constants/math/float64-sqrt-two-pi",SQRT_TWO_PI
+"@stdlib/utils/stack",Stack
+"@stdlib/string/startcase",startcase
+"@stdlib/string/starts-with",startsWith
+"@stdlib/datasets/stopwords-en",STOPWORDS_EN
+"@stdlib/array/to-strided-iterator",stridedarray2iterator
+"@stdlib/streams/node/from-strided-array",stridedArrayStream
+"@stdlib/buffer/from-string",string2buffer
+"@stdlib/ndarray/sub2ind",sub2ind
+"@stdlib/datasets/suthaharan-multi-hop-sensor-network",SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK
+"@stdlib/datasets/suthaharan-single-hop-sensor-network",SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK
+"@stdlib/symbol/ctor",Symbol
+"@stdlib/utils/tabulate",tabulate
+"@stdlib/utils/tabulate-by",tabulateBy
+"@stdlib/utils/async/tabulate-by",tabulateByAsync
+"@stdlib/time/tic",tic
+"@stdlib/utils/timeit",timeit
+"@stdlib/os/tmpdir",tmpdir
+"@stdlib/time/toc",toc
+"@stdlib/nlp/tokenize",tokenize
+"@stdlib/streams/node/transform",transformStream
+"@stdlib/string/trim",trim
+"@stdlib/utils/try-catch",trycatch
+"@stdlib/utils/async/try-catch",trycatchAsync
+"@stdlib/utils/try-function",tryFunction
+"@stdlib/utils/try-require",tryRequire
+"@stdlib/utils/try-then",trythen
+"@stdlib/utils/async/try-then",trythenAsync
+"@stdlib/stats/ttest",ttest
+"@stdlib/stats/ttest2",ttest2
+"@stdlib/constants/math/float64-two-pi",TWO_PI
+"@stdlib/array/typed",typedarray
+"@stdlib/array/to-json",typedarray2json
+"@stdlib/array/typed-complex-ctors",typedarrayComplexCtors
+"@stdlib/array/typed-complex-dtypes",typedarrayComplexDataTypes
+"@stdlib/array/typed-ctors",typedarrayCtors
+"@stdlib/array/typed-dtypes",typedarrayDataTypes
+"@stdlib/array/pool",typedarraypool
+"@stdlib/utils/type-max",typemax
+"@stdlib/utils/type-min",typemin
+"@stdlib/utils/type-of",typeOf
+"@stdlib/constants/math/uint8-max",UINT8_MAX
+"@stdlib/constants/math/uint8-num-bytes",UINT8_NUM_BYTES
+"@stdlib/array/uint8",Uint8Array
+"@stdlib/array/uint8c",Uint8ClampedArray
+"@stdlib/constants/math/uint16-max",UINT16_MAX
+"@stdlib/constants/math/uint16-num-bytes",UINT16_NUM_BYTES
+"@stdlib/array/uint16",Uint16Array
+"@stdlib/constants/math/uint32-max",UINT32_MAX
+"@stdlib/constants/math/uint32-num-bytes",UINT32_NUM_BYTES
+"@stdlib/array/uint32",Uint32Array
+"@stdlib/process/umask",umask
+"@stdlib/string/uncapitalize",uncapitalize
+"@stdlib/utils/uncapitalize-keys",uncapitalizeKeys
+"@stdlib/utils/uncurry",uncurry
+"@stdlib/utils/uncurry-right",uncurryRight
+"@stdlib/constants/string/unicode-max",UNICODE_MAX
+"@stdlib/constants/string/unicode-max-bmp",UNICODE_MAX_BMP
+"@stdlib/plot/sparklines/unicode/column",UnicodeColumnChartSparkline
+"@stdlib/plot/sparklines/unicode/line",UnicodeLineChartSparkline
+"@stdlib/plot/sparklines/unicode",UnicodeSparkline
+"@stdlib/plot/sparklines/unicode/tristate",UnicodeTristateChartSparkline
+"@stdlib/plot/sparklines/unicode/up-down",UnicodeUpDownChartSparkline
+"@stdlib/plot/sparklines/unicode/win-loss",UnicodeWinLossChartSparkline
+"@stdlib/fs/unlink",unlink
+"@stdlib/utils/unshift",unshift
+"@stdlib/utils/until",until
+"@stdlib/utils/async/until",untilAsync
+"@stdlib/utils/until-each",untilEach
+"@stdlib/utils/until-each-right",untilEachRight
+"@stdlib/utils/unzip",unzip
+"@stdlib/string/uppercase",uppercase
+"@stdlib/utils/uppercase-keys",uppercaseKeys
+"@stdlib/datasets/us-states-abbr",US_STATES_ABBR
+"@stdlib/datasets/us-states-capitals",US_STATES_CAPITALS
+"@stdlib/datasets/us-states-capitals-names",US_STATES_CAPITALS_NAMES
+"@stdlib/datasets/us-states-names",US_STATES_NAMES
+"@stdlib/datasets/us-states-names-capitals",US_STATES_NAMES_CAPITALS
+"@stdlib/string/utf16-to-utf8-array",utf16ToUTF8Array
+"@stdlib/stats/vartest",vartest
+"@stdlib/utils/async/series-waterfall",waterfall
+"@stdlib/utils/async/while",whileAsync
+"@stdlib/utils/while-each",whileEach
+"@stdlib/utils/while-each-right",whileEachRight
+"@stdlib/utils/while",whilst
+"@stdlib/utils/writable-properties",writableProperties
+"@stdlib/utils/writable-properties-in",writablePropertiesIn
+"@stdlib/utils/writable-property-names",writablePropertyNames
+"@stdlib/utils/writable-property-names-in",writablePropertyNamesIn
+"@stdlib/utils/writable-property-symbols",writablePropertySymbols
+"@stdlib/utils/writable-property-symbols-in",writablePropertySymbolsIn
+"@stdlib/fs/write-file",writeFile
+"@stdlib/utils/zip",zip
+"@stdlib/stats/ztest",ztest
+"@stdlib/stats/ztest2",ztest2
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json
new file mode 100644
index 000000000000..8c406f657bb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/data/data.json
@@ -0,0 +1 @@
+{"@stdlib/datasets/afinn-96":"AFINN_96","@stdlib/datasets/afinn-111":"AFINN_111","@stdlib/namespace/alias2pkg":"alias2pkg","@stdlib/namespace/alias2related":"alias2related","@stdlib/namespace/aliases":"aliases","@stdlib/buffer/alloc-unsafe":"allocUnsafe","@stdlib/stats/anova1":"anova1","@stdlib/datasets/anscombes-quartet":"ANSCOMBES_QUARTET","@stdlib/utils/any":"any","@stdlib/utils/any-by":"anyBy","@stdlib/utils/async/any-by":"anyByAsync","@stdlib/utils/any-by-right":"anyByRight","@stdlib/utils/async/any-by-right":"anyByRightAsync","@stdlib/constants/math/float64-apery":"APERY","@stdlib/utils/append":"append","@stdlib/os/arch":"ARCH","@stdlib/utils/argument-function":"argumentFunction","@stdlib/process/argv":"ARGV","@stdlib/ndarray/array":"array","@stdlib/buffer/from-array":"array2buffer","@stdlib/array/to-iterator":"array2iterator","@stdlib/array/to-iterator-right":"array2iteratorRight","@stdlib/array/buffer":"ArrayBuffer","@stdlib/buffer/from-arraybuffer":"arraybuffer2buffer","@stdlib/array/ctors":"arrayCtors","@stdlib/array/dtype":"arrayDataType","@stdlib/array/dtypes":"arrayDataTypes","@stdlib/array/min-dtype":"arrayMinDataType","@stdlib/array/next-dtype":"arrayNextDataType","@stdlib/array/promotion-rules":"arrayPromotionRules","@stdlib/array/safe-casts":"arraySafeCasts","@stdlib/array/same-kind-casts":"arraySameKindCasts","@stdlib/array/shape":"arrayShape","@stdlib/streams/node/from-array":"arrayStream","@stdlib/array/to-view-iterator":"arrayview2iterator","@stdlib/array/to-view-iterator-right":"arrayview2iteratorRight","@stdlib/symbol/async-iterator":"AsyncIteratorSymbol","@stdlib/stats/bartlett-test":"bartlettTest","@stdlib/math/base/special/abs":"base.abs","@stdlib/math/base/special/abs2":"base.abs2","@stdlib/math/base/utils/absolute-difference":"base.absdiff","@stdlib/math/base/special/int32-abs":"base.absInt32","@stdlib/math/base/special/acos":"base.acos","@stdlib/math/base/special/acosh":"base.acosh","@stdlib/math/base/special/acoth":"base.acoth","@stdlib/math/base/special/acovercos":"base.acovercos","@stdlib/math/base/special/acoversin":"base.acoversin","@stdlib/math/base/special/ahavercos":"base.ahavercos","@stdlib/math/base/special/ahaversin":"base.ahaversin","@stdlib/math/base/special/asin":"base.asin","@stdlib/math/base/special/asinh":"base.asinh","@stdlib/math/base/special/atan":"base.atan","@stdlib/math/base/special/atan2":"base.atan2","@stdlib/math/base/special/atanh":"base.atanh","@stdlib/math/base/special/avercos":"base.avercos","@stdlib/math/base/special/aversin":"base.aversin","@stdlib/math/base/special/bernoulli":"base.bernoulli","@stdlib/math/base/special/besselj0":"base.besselj0","@stdlib/math/base/special/besselj1":"base.besselj1","@stdlib/math/base/special/bessely0":"base.bessely0","@stdlib/math/base/special/bessely1":"base.bessely1","@stdlib/math/base/special/beta":"base.beta","@stdlib/math/base/special/betainc":"base.betainc","@stdlib/math/base/special/betaincinv":"base.betaincinv","@stdlib/math/base/special/betaln":"base.betaln","@stdlib/math/base/special/binet":"base.binet","@stdlib/math/base/special/binomcoef":"base.binomcoef","@stdlib/math/base/special/binomcoefln":"base.binomcoefln","@stdlib/math/base/special/boxcox":"base.boxcox","@stdlib/math/base/special/boxcox1p":"base.boxcox1p","@stdlib/math/base/special/boxcox1pinv":"base.boxcox1pinv","@stdlib/math/base/special/boxcoxinv":"base.boxcoxinv","@stdlib/math/base/complex/abs":"base.cabs","@stdlib/math/base/complex/abs2":"base.cabs2","@stdlib/math/base/complex/add":"base.cadd","@stdlib/math/base/special/cbrt":"base.cbrt","@stdlib/math/base/complex/ceil":"base.cceil","@stdlib/math/base/complex/ceiln":"base.cceiln","@stdlib/math/base/complex/cis":"base.ccis","@stdlib/math/base/complex/divide":"base.cdiv","@stdlib/math/base/special/ceil":"base.ceil","@stdlib/math/base/special/ceil2":"base.ceil2","@stdlib/math/base/special/ceil10":"base.ceil10","@stdlib/math/base/special/ceilb":"base.ceilb","@stdlib/math/base/special/ceiln":"base.ceiln","@stdlib/math/base/special/ceilsd":"base.ceilsd","@stdlib/math/base/complex/exp":"base.cexp","@stdlib/math/base/complex/flipsign":"base.cflipsign","@stdlib/math/base/complex/floor":"base.cfloor","@stdlib/math/base/complex/floorn":"base.cfloorn","@stdlib/math/base/complex/inv":"base.cinv","@stdlib/math/base/special/clamp":"base.clamp","@stdlib/math/base/complex/multiply":"base.cmul","@stdlib/math/base/complex/negate":"base.cneg","@stdlib/math/base/tools/continued-fraction":"base.continuedFraction","@stdlib/math/base/special/copysign":"base.copysign","@stdlib/math/base/special/cos":"base.cos","@stdlib/math/base/special/cosh":"base.cosh","@stdlib/math/base/special/cosm1":"base.cosm1","@stdlib/math/base/special/cospi":"base.cospi","@stdlib/math/base/special/covercos":"base.covercos","@stdlib/math/base/special/coversin":"base.coversin","@stdlib/math/base/complex/phase":"base.cphase","@stdlib/math/base/complex/polar":"base.cpolar","@stdlib/math/base/complex/round":"base.cround","@stdlib/math/base/complex/roundn":"base.croundn","@stdlib/math/base/complex/signum":"base.csignum","@stdlib/math/base/complex/subtract":"base.csub","@stdlib/blas/base/dasum":"base.dasum","@stdlib/blas/base/daxpy":"base.daxpy","@stdlib/blas/base/dcopy":"base.dcopy","@stdlib/math/base/special/deg2rad":"base.deg2rad","@stdlib/math/base/special/digamma":"base.digamma","@stdlib/math/base/special/dirac-delta":"base.diracDelta","@stdlib/stats/base/dists/arcsine/ctor":"base.dists.arcsine.Arcsine","@stdlib/stats/base/dists/arcsine/cdf":"base.dists.arcsine.cdf","@stdlib/stats/base/dists/arcsine/entropy":"base.dists.arcsine.entropy","@stdlib/stats/base/dists/arcsine/kurtosis":"base.dists.arcsine.kurtosis","@stdlib/stats/base/dists/arcsine/logcdf":"base.dists.arcsine.logcdf","@stdlib/stats/base/dists/arcsine/logpdf":"base.dists.arcsine.logpdf","@stdlib/stats/base/dists/arcsine/mean":"base.dists.arcsine.mean","@stdlib/stats/base/dists/arcsine/median":"base.dists.arcsine.median","@stdlib/stats/base/dists/arcsine/mode":"base.dists.arcsine.mode","@stdlib/stats/base/dists/arcsine/pdf":"base.dists.arcsine.pdf","@stdlib/stats/base/dists/arcsine/quantile":"base.dists.arcsine.quantile","@stdlib/stats/base/dists/arcsine/skewness":"base.dists.arcsine.skewness","@stdlib/stats/base/dists/arcsine/stdev":"base.dists.arcsine.stdev","@stdlib/stats/base/dists/arcsine/variance":"base.dists.arcsine.variance","@stdlib/stats/base/dists/bernoulli/ctor":"base.dists.bernoulli.Bernoulli","@stdlib/stats/base/dists/bernoulli/cdf":"base.dists.bernoulli.cdf","@stdlib/stats/base/dists/bernoulli/entropy":"base.dists.bernoulli.entropy","@stdlib/stats/base/dists/bernoulli/kurtosis":"base.dists.bernoulli.kurtosis","@stdlib/stats/base/dists/bernoulli/mean":"base.dists.bernoulli.mean","@stdlib/stats/base/dists/bernoulli/median":"base.dists.bernoulli.median","@stdlib/stats/base/dists/bernoulli/mgf":"base.dists.bernoulli.mgf","@stdlib/stats/base/dists/bernoulli/mode":"base.dists.bernoulli.mode","@stdlib/stats/base/dists/bernoulli/pmf":"base.dists.bernoulli.pmf","@stdlib/stats/base/dists/bernoulli/quantile":"base.dists.bernoulli.quantile","@stdlib/stats/base/dists/bernoulli/skewness":"base.dists.bernoulli.skewness","@stdlib/stats/base/dists/bernoulli/stdev":"base.dists.bernoulli.stdev","@stdlib/stats/base/dists/bernoulli/variance":"base.dists.bernoulli.variance","@stdlib/stats/base/dists/beta/ctor":"base.dists.beta.Beta","@stdlib/stats/base/dists/beta/cdf":"base.dists.beta.cdf","@stdlib/stats/base/dists/beta/entropy":"base.dists.beta.entropy","@stdlib/stats/base/dists/beta/kurtosis":"base.dists.beta.kurtosis","@stdlib/stats/base/dists/beta/logcdf":"base.dists.beta.logcdf","@stdlib/stats/base/dists/beta/logpdf":"base.dists.beta.logpdf","@stdlib/stats/base/dists/beta/mean":"base.dists.beta.mean","@stdlib/stats/base/dists/beta/median":"base.dists.beta.median","@stdlib/stats/base/dists/beta/mgf":"base.dists.beta.mgf","@stdlib/stats/base/dists/beta/mode":"base.dists.beta.mode","@stdlib/stats/base/dists/beta/pdf":"base.dists.beta.pdf","@stdlib/stats/base/dists/beta/quantile":"base.dists.beta.quantile","@stdlib/stats/base/dists/beta/skewness":"base.dists.beta.skewness","@stdlib/stats/base/dists/beta/stdev":"base.dists.beta.stdev","@stdlib/stats/base/dists/beta/variance":"base.dists.beta.variance","@stdlib/stats/base/dists/betaprime/ctor":"base.dists.betaprime.BetaPrime","@stdlib/stats/base/dists/betaprime/cdf":"base.dists.betaprime.cdf","@stdlib/stats/base/dists/betaprime/kurtosis":"base.dists.betaprime.kurtosis","@stdlib/stats/base/dists/betaprime/logcdf":"base.dists.betaprime.logcdf","@stdlib/stats/base/dists/betaprime/logpdf":"base.dists.betaprime.logpdf","@stdlib/stats/base/dists/betaprime/mean":"base.dists.betaprime.mean","@stdlib/stats/base/dists/betaprime/mode":"base.dists.betaprime.mode","@stdlib/stats/base/dists/betaprime/pdf":"base.dists.betaprime.pdf","@stdlib/stats/base/dists/betaprime/quantile":"base.dists.betaprime.quantile","@stdlib/stats/base/dists/betaprime/skewness":"base.dists.betaprime.skewness","@stdlib/stats/base/dists/betaprime/stdev":"base.dists.betaprime.stdev","@stdlib/stats/base/dists/betaprime/variance":"base.dists.betaprime.variance","@stdlib/stats/base/dists/binomial/ctor":"base.dists.binomial.Binomial","@stdlib/stats/base/dists/binomial/cdf":"base.dists.binomial.cdf","@stdlib/stats/base/dists/binomial/entropy":"base.dists.binomial.entropy","@stdlib/stats/base/dists/binomial/kurtosis":"base.dists.binomial.kurtosis","@stdlib/stats/base/dists/binomial/logpmf":"base.dists.binomial.logpmf","@stdlib/stats/base/dists/binomial/mean":"base.dists.binomial.mean","@stdlib/stats/base/dists/binomial/median":"base.dists.binomial.median","@stdlib/stats/base/dists/binomial/mgf":"base.dists.binomial.mgf","@stdlib/stats/base/dists/binomial/mode":"base.dists.binomial.mode","@stdlib/stats/base/dists/binomial/pmf":"base.dists.binomial.pmf","@stdlib/stats/base/dists/binomial/quantile":"base.dists.binomial.quantile","@stdlib/stats/base/dists/binomial/skewness":"base.dists.binomial.skewness","@stdlib/stats/base/dists/binomial/stdev":"base.dists.binomial.stdev","@stdlib/stats/base/dists/binomial/variance":"base.dists.binomial.variance","@stdlib/stats/base/dists/cauchy/ctor":"base.dists.cauchy.Cauchy","@stdlib/stats/base/dists/cauchy/cdf":"base.dists.cauchy.cdf","@stdlib/stats/base/dists/cauchy/entropy":"base.dists.cauchy.entropy","@stdlib/stats/base/dists/cauchy/logcdf":"base.dists.cauchy.logcdf","@stdlib/stats/base/dists/cauchy/logpdf":"base.dists.cauchy.logpdf","@stdlib/stats/base/dists/cauchy/median":"base.dists.cauchy.median","@stdlib/stats/base/dists/cauchy/mode":"base.dists.cauchy.mode","@stdlib/stats/base/dists/cauchy/pdf":"base.dists.cauchy.pdf","@stdlib/stats/base/dists/cauchy/quantile":"base.dists.cauchy.quantile","@stdlib/stats/base/dists/chi/cdf":"base.dists.chi.cdf","@stdlib/stats/base/dists/chi/ctor":"base.dists.chi.Chi","@stdlib/stats/base/dists/chi/entropy":"base.dists.chi.entropy","@stdlib/stats/base/dists/chi/kurtosis":"base.dists.chi.kurtosis","@stdlib/stats/base/dists/chi/logpdf":"base.dists.chi.logpdf","@stdlib/stats/base/dists/chi/mean":"base.dists.chi.mean","@stdlib/stats/base/dists/chi/mode":"base.dists.chi.mode","@stdlib/stats/base/dists/chi/pdf":"base.dists.chi.pdf","@stdlib/stats/base/dists/chi/quantile":"base.dists.chi.quantile","@stdlib/stats/base/dists/chi/skewness":"base.dists.chi.skewness","@stdlib/stats/base/dists/chi/stdev":"base.dists.chi.stdev","@stdlib/stats/base/dists/chi/variance":"base.dists.chi.variance","@stdlib/stats/base/dists/chisquare/cdf":"base.dists.chisquare.cdf","@stdlib/stats/base/dists/chisquare/ctor":"base.dists.chisquare.ChiSquare","@stdlib/stats/base/dists/chisquare/entropy":"base.dists.chisquare.entropy","@stdlib/stats/base/dists/chisquare/kurtosis":"base.dists.chisquare.kurtosis","@stdlib/stats/base/dists/chisquare/logpdf":"base.dists.chisquare.logpdf","@stdlib/stats/base/dists/chisquare/mean":"base.dists.chisquare.mean","@stdlib/stats/base/dists/chisquare/mgf":"base.dists.chisquare.mgf","@stdlib/stats/base/dists/chisquare/mode":"base.dists.chisquare.mode","@stdlib/stats/base/dists/chisquare/pdf":"base.dists.chisquare.pdf","@stdlib/stats/base/dists/chisquare/quantile":"base.dists.chisquare.quantile","@stdlib/stats/base/dists/chisquare/skewness":"base.dists.chisquare.skewness","@stdlib/stats/base/dists/chisquare/stdev":"base.dists.chisquare.stdev","@stdlib/stats/base/dists/chisquare/variance":"base.dists.chisquare.variance","@stdlib/stats/base/dists/cosine/cdf":"base.dists.cosine.cdf","@stdlib/stats/base/dists/cosine/ctor":"base.dists.cosine.Cosine","@stdlib/stats/base/dists/cosine/kurtosis":"base.dists.cosine.kurtosis","@stdlib/stats/base/dists/cosine/logcdf":"base.dists.cosine.logcdf","@stdlib/stats/base/dists/cosine/logpdf":"base.dists.cosine.logpdf","@stdlib/stats/base/dists/cosine/mean":"base.dists.cosine.mean","@stdlib/stats/base/dists/cosine/median":"base.dists.cosine.median","@stdlib/stats/base/dists/cosine/mgf":"base.dists.cosine.mgf","@stdlib/stats/base/dists/cosine/mode":"base.dists.cosine.mode","@stdlib/stats/base/dists/cosine/pdf":"base.dists.cosine.pdf","@stdlib/stats/base/dists/cosine/quantile":"base.dists.cosine.quantile","@stdlib/stats/base/dists/cosine/skewness":"base.dists.cosine.skewness","@stdlib/stats/base/dists/cosine/stdev":"base.dists.cosine.stdev","@stdlib/stats/base/dists/cosine/variance":"base.dists.cosine.variance","@stdlib/stats/base/dists/degenerate/cdf":"base.dists.degenerate.cdf","@stdlib/stats/base/dists/degenerate/ctor":"base.dists.degenerate.Degenerate","@stdlib/stats/base/dists/degenerate/entropy":"base.dists.degenerate.entropy","@stdlib/stats/base/dists/degenerate/logcdf":"base.dists.degenerate.logcdf","@stdlib/stats/base/dists/degenerate/logpdf":"base.dists.degenerate.logpdf","@stdlib/stats/base/dists/degenerate/logpmf":"base.dists.degenerate.logpmf","@stdlib/stats/base/dists/degenerate/mean":"base.dists.degenerate.mean","@stdlib/stats/base/dists/degenerate/median":"base.dists.degenerate.median","@stdlib/stats/base/dists/degenerate/mgf":"base.dists.degenerate.mgf","@stdlib/stats/base/dists/degenerate/mode":"base.dists.degenerate.mode","@stdlib/stats/base/dists/degenerate/pdf":"base.dists.degenerate.pdf","@stdlib/stats/base/dists/degenerate/pmf":"base.dists.degenerate.pmf","@stdlib/stats/base/dists/degenerate/quantile":"base.dists.degenerate.quantile","@stdlib/stats/base/dists/degenerate/stdev":"base.dists.degenerate.stdev","@stdlib/stats/base/dists/degenerate/variance":"base.dists.degenerate.variance","@stdlib/stats/base/dists/discrete-uniform/cdf":"base.dists.discreteUniform.cdf","@stdlib/stats/base/dists/discrete-uniform/ctor":"base.dists.discreteUniform.DiscreteUniform","@stdlib/stats/base/dists/discrete-uniform/kurtosis":"base.dists.discreteUniform.kurtosis","@stdlib/stats/base/dists/discrete-uniform/logcdf":"base.dists.discreteUniform.logcdf","@stdlib/stats/base/dists/discrete-uniform/logpmf":"base.dists.discreteUniform.logpmf","@stdlib/stats/base/dists/discrete-uniform/mean":"base.dists.discreteUniform.mean","@stdlib/stats/base/dists/discrete-uniform/median":"base.dists.discreteUniform.median","@stdlib/stats/base/dists/discrete-uniform/mgf":"base.dists.discreteUniform.mgf","@stdlib/stats/base/dists/discrete-uniform/pmf":"base.dists.discreteUniform.pmf","@stdlib/stats/base/dists/discrete-uniform/quantile":"base.dists.discreteUniform.quantile","@stdlib/stats/base/dists/discrete-uniform/skewness":"base.dists.discreteUniform.skewness","@stdlib/stats/base/dists/discrete-uniform/stdev":"base.dists.discreteUniform.stdev","@stdlib/stats/base/dists/discrete-uniform/variance":"base.dists.discreteUniform.variance","@stdlib/stats/base/dists/erlang/cdf":"base.dists.erlang.cdf","@stdlib/stats/base/dists/erlang/entropy":"base.dists.erlang.entropy","@stdlib/stats/base/dists/erlang/ctor":"base.dists.erlang.Erlang","@stdlib/stats/base/dists/erlang/kurtosis":"base.dists.erlang.kurtosis","@stdlib/stats/base/dists/erlang/logpdf":"base.dists.erlang.logpdf","@stdlib/stats/base/dists/erlang/mean":"base.dists.erlang.mean","@stdlib/stats/base/dists/erlang/mgf":"base.dists.erlang.mgf","@stdlib/stats/base/dists/erlang/mode":"base.dists.erlang.mode","@stdlib/stats/base/dists/erlang/pdf":"base.dists.erlang.pdf","@stdlib/stats/base/dists/erlang/quantile":"base.dists.erlang.quantile","@stdlib/stats/base/dists/erlang/skewness":"base.dists.erlang.skewness","@stdlib/stats/base/dists/erlang/stdev":"base.dists.erlang.stdev","@stdlib/stats/base/dists/erlang/variance":"base.dists.erlang.variance","@stdlib/stats/base/dists/exponential/cdf":"base.dists.exponential.cdf","@stdlib/stats/base/dists/exponential/entropy":"base.dists.exponential.entropy","@stdlib/stats/base/dists/exponential/ctor":"base.dists.exponential.Exponential","@stdlib/stats/base/dists/exponential/kurtosis":"base.dists.exponential.kurtosis","@stdlib/stats/base/dists/exponential/logcdf":"base.dists.exponential.logcdf","@stdlib/stats/base/dists/exponential/logpdf":"base.dists.exponential.logpdf","@stdlib/stats/base/dists/exponential/mean":"base.dists.exponential.mean","@stdlib/stats/base/dists/exponential/median":"base.dists.exponential.median","@stdlib/stats/base/dists/exponential/mgf":"base.dists.exponential.mgf","@stdlib/stats/base/dists/exponential/mode":"base.dists.exponential.mode","@stdlib/stats/base/dists/exponential/pdf":"base.dists.exponential.pdf","@stdlib/stats/base/dists/exponential/quantile":"base.dists.exponential.quantile","@stdlib/stats/base/dists/exponential/skewness":"base.dists.exponential.skewness","@stdlib/stats/base/dists/exponential/stdev":"base.dists.exponential.stdev","@stdlib/stats/base/dists/exponential/variance":"base.dists.exponential.variance","@stdlib/stats/base/dists/f/cdf":"base.dists.f.cdf","@stdlib/stats/base/dists/f/entropy":"base.dists.f.entropy","@stdlib/stats/base/dists/f/ctor":"base.dists.f.F","@stdlib/stats/base/dists/f/kurtosis":"base.dists.f.kurtosis","@stdlib/stats/base/dists/f/mean":"base.dists.f.mean","@stdlib/stats/base/dists/f/mode":"base.dists.f.mode","@stdlib/stats/base/dists/f/pdf":"base.dists.f.pdf","@stdlib/stats/base/dists/f/quantile":"base.dists.f.quantile","@stdlib/stats/base/dists/f/skewness":"base.dists.f.skewness","@stdlib/stats/base/dists/f/stdev":"base.dists.f.stdev","@stdlib/stats/base/dists/f/variance":"base.dists.f.variance","@stdlib/stats/base/dists/frechet/cdf":"base.dists.frechet.cdf","@stdlib/stats/base/dists/frechet/entropy":"base.dists.frechet.entropy","@stdlib/stats/base/dists/frechet/ctor":"base.dists.frechet.Frechet","@stdlib/stats/base/dists/frechet/kurtosis":"base.dists.frechet.kurtosis","@stdlib/stats/base/dists/frechet/logcdf":"base.dists.frechet.logcdf","@stdlib/stats/base/dists/frechet/logpdf":"base.dists.frechet.logpdf","@stdlib/stats/base/dists/frechet/mean":"base.dists.frechet.mean","@stdlib/stats/base/dists/frechet/median":"base.dists.frechet.median","@stdlib/stats/base/dists/frechet/mode":"base.dists.frechet.mode","@stdlib/stats/base/dists/frechet/pdf":"base.dists.frechet.pdf","@stdlib/stats/base/dists/frechet/quantile":"base.dists.frechet.quantile","@stdlib/stats/base/dists/frechet/skewness":"base.dists.frechet.skewness","@stdlib/stats/base/dists/frechet/stdev":"base.dists.frechet.stdev","@stdlib/stats/base/dists/frechet/variance":"base.dists.frechet.variance","@stdlib/stats/base/dists/gamma/cdf":"base.dists.gamma.cdf","@stdlib/stats/base/dists/gamma/entropy":"base.dists.gamma.entropy","@stdlib/stats/base/dists/gamma/ctor":"base.dists.gamma.Gamma","@stdlib/stats/base/dists/gamma/kurtosis":"base.dists.gamma.kurtosis","@stdlib/stats/base/dists/gamma/logpdf":"base.dists.gamma.logpdf","@stdlib/stats/base/dists/gamma/mean":"base.dists.gamma.mean","@stdlib/stats/base/dists/gamma/mgf":"base.dists.gamma.mgf","@stdlib/stats/base/dists/gamma/mode":"base.dists.gamma.mode","@stdlib/stats/base/dists/gamma/pdf":"base.dists.gamma.pdf","@stdlib/stats/base/dists/gamma/quantile":"base.dists.gamma.quantile","@stdlib/stats/base/dists/gamma/skewness":"base.dists.gamma.skewness","@stdlib/stats/base/dists/gamma/stdev":"base.dists.gamma.stdev","@stdlib/stats/base/dists/gamma/variance":"base.dists.gamma.variance","@stdlib/stats/base/dists/geometric/cdf":"base.dists.geometric.cdf","@stdlib/stats/base/dists/geometric/entropy":"base.dists.geometric.entropy","@stdlib/stats/base/dists/geometric/ctor":"base.dists.geometric.Geometric","@stdlib/stats/base/dists/geometric/kurtosis":"base.dists.geometric.kurtosis","@stdlib/stats/base/dists/geometric/logcdf":"base.dists.geometric.logcdf","@stdlib/stats/base/dists/geometric/logpmf":"base.dists.geometric.logpmf","@stdlib/stats/base/dists/geometric/mean":"base.dists.geometric.mean","@stdlib/stats/base/dists/geometric/median":"base.dists.geometric.median","@stdlib/stats/base/dists/geometric/mgf":"base.dists.geometric.mgf","@stdlib/stats/base/dists/geometric/mode":"base.dists.geometric.mode","@stdlib/stats/base/dists/geometric/pmf":"base.dists.geometric.pmf","@stdlib/stats/base/dists/geometric/quantile":"base.dists.geometric.quantile","@stdlib/stats/base/dists/geometric/skewness":"base.dists.geometric.skewness","@stdlib/stats/base/dists/geometric/stdev":"base.dists.geometric.stdev","@stdlib/stats/base/dists/geometric/variance":"base.dists.geometric.variance","@stdlib/stats/base/dists/gumbel/cdf":"base.dists.gumbel.cdf","@stdlib/stats/base/dists/gumbel/entropy":"base.dists.gumbel.entropy","@stdlib/stats/base/dists/gumbel/ctor":"base.dists.gumbel.Gumbel","@stdlib/stats/base/dists/gumbel/kurtosis":"base.dists.gumbel.kurtosis","@stdlib/stats/base/dists/gumbel/logcdf":"base.dists.gumbel.logcdf","@stdlib/stats/base/dists/gumbel/logpdf":"base.dists.gumbel.logpdf","@stdlib/stats/base/dists/gumbel/mean":"base.dists.gumbel.mean","@stdlib/stats/base/dists/gumbel/median":"base.dists.gumbel.median","@stdlib/stats/base/dists/gumbel/mgf":"base.dists.gumbel.mgf","@stdlib/stats/base/dists/gumbel/mode":"base.dists.gumbel.mode","@stdlib/stats/base/dists/gumbel/pdf":"base.dists.gumbel.pdf","@stdlib/stats/base/dists/gumbel/quantile":"base.dists.gumbel.quantile","@stdlib/stats/base/dists/gumbel/skewness":"base.dists.gumbel.skewness","@stdlib/stats/base/dists/gumbel/stdev":"base.dists.gumbel.stdev","@stdlib/stats/base/dists/gumbel/variance":"base.dists.gumbel.variance","@stdlib/stats/base/dists/hypergeometric/cdf":"base.dists.hypergeometric.cdf","@stdlib/stats/base/dists/hypergeometric/ctor":"base.dists.hypergeometric.Hypergeometric","@stdlib/stats/base/dists/hypergeometric/kurtosis":"base.dists.hypergeometric.kurtosis","@stdlib/stats/base/dists/hypergeometric/logpmf":"base.dists.hypergeometric.logpmf","@stdlib/stats/base/dists/hypergeometric/mean":"base.dists.hypergeometric.mean","@stdlib/stats/base/dists/hypergeometric/mode":"base.dists.hypergeometric.mode","@stdlib/stats/base/dists/hypergeometric/pmf":"base.dists.hypergeometric.pmf","@stdlib/stats/base/dists/hypergeometric/quantile":"base.dists.hypergeometric.quantile","@stdlib/stats/base/dists/hypergeometric/skewness":"base.dists.hypergeometric.skewness","@stdlib/stats/base/dists/hypergeometric/stdev":"base.dists.hypergeometric.stdev","@stdlib/stats/base/dists/hypergeometric/variance":"base.dists.hypergeometric.variance","@stdlib/stats/base/dists/invgamma/cdf":"base.dists.invgamma.cdf","@stdlib/stats/base/dists/invgamma/entropy":"base.dists.invgamma.entropy","@stdlib/stats/base/dists/invgamma/ctor":"base.dists.invgamma.InvGamma","@stdlib/stats/base/dists/invgamma/kurtosis":"base.dists.invgamma.kurtosis","@stdlib/stats/base/dists/invgamma/logpdf":"base.dists.invgamma.logpdf","@stdlib/stats/base/dists/invgamma/mean":"base.dists.invgamma.mean","@stdlib/stats/base/dists/invgamma/mode":"base.dists.invgamma.mode","@stdlib/stats/base/dists/invgamma/pdf":"base.dists.invgamma.pdf","@stdlib/stats/base/dists/invgamma/quantile":"base.dists.invgamma.quantile","@stdlib/stats/base/dists/invgamma/skewness":"base.dists.invgamma.skewness","@stdlib/stats/base/dists/invgamma/stdev":"base.dists.invgamma.stdev","@stdlib/stats/base/dists/invgamma/variance":"base.dists.invgamma.variance","@stdlib/stats/base/dists/kumaraswamy/cdf":"base.dists.kumaraswamy.cdf","@stdlib/stats/base/dists/kumaraswamy/ctor":"base.dists.kumaraswamy.Kumaraswamy","@stdlib/stats/base/dists/kumaraswamy/kurtosis":"base.dists.kumaraswamy.kurtosis","@stdlib/stats/base/dists/kumaraswamy/logcdf":"base.dists.kumaraswamy.logcdf","@stdlib/stats/base/dists/kumaraswamy/logpdf":"base.dists.kumaraswamy.logpdf","@stdlib/stats/base/dists/kumaraswamy/mean":"base.dists.kumaraswamy.mean","@stdlib/stats/base/dists/kumaraswamy/median":"base.dists.kumaraswamy.median","@stdlib/stats/base/dists/kumaraswamy/mode":"base.dists.kumaraswamy.mode","@stdlib/stats/base/dists/kumaraswamy/pdf":"base.dists.kumaraswamy.pdf","@stdlib/stats/base/dists/kumaraswamy/quantile":"base.dists.kumaraswamy.quantile","@stdlib/stats/base/dists/kumaraswamy/skewness":"base.dists.kumaraswamy.skewness","@stdlib/stats/base/dists/kumaraswamy/stdev":"base.dists.kumaraswamy.stdev","@stdlib/stats/base/dists/kumaraswamy/variance":"base.dists.kumaraswamy.variance","@stdlib/stats/base/dists/laplace/cdf":"base.dists.laplace.cdf","@stdlib/stats/base/dists/laplace/entropy":"base.dists.laplace.entropy","@stdlib/stats/base/dists/laplace/kurtosis":"base.dists.laplace.kurtosis","@stdlib/stats/base/dists/laplace/ctor":"base.dists.laplace.Laplace","@stdlib/stats/base/dists/laplace/logcdf":"base.dists.laplace.logcdf","@stdlib/stats/base/dists/laplace/logpdf":"base.dists.laplace.logpdf","@stdlib/stats/base/dists/laplace/mean":"base.dists.laplace.mean","@stdlib/stats/base/dists/laplace/median":"base.dists.laplace.median","@stdlib/stats/base/dists/laplace/mgf":"base.dists.laplace.mgf","@stdlib/stats/base/dists/laplace/mode":"base.dists.laplace.mode","@stdlib/stats/base/dists/laplace/pdf":"base.dists.laplace.pdf","@stdlib/stats/base/dists/laplace/quantile":"base.dists.laplace.quantile","@stdlib/stats/base/dists/laplace/skewness":"base.dists.laplace.skewness","@stdlib/stats/base/dists/laplace/stdev":"base.dists.laplace.stdev","@stdlib/stats/base/dists/laplace/variance":"base.dists.laplace.variance","@stdlib/stats/base/dists/levy/cdf":"base.dists.levy.cdf","@stdlib/stats/base/dists/levy/entropy":"base.dists.levy.entropy","@stdlib/stats/base/dists/levy/ctor":"base.dists.levy.Levy","@stdlib/stats/base/dists/levy/logcdf":"base.dists.levy.logcdf","@stdlib/stats/base/dists/levy/logpdf":"base.dists.levy.logpdf","@stdlib/stats/base/dists/levy/mean":"base.dists.levy.mean","@stdlib/stats/base/dists/levy/median":"base.dists.levy.median","@stdlib/stats/base/dists/levy/mode":"base.dists.levy.mode","@stdlib/stats/base/dists/levy/pdf":"base.dists.levy.pdf","@stdlib/stats/base/dists/levy/quantile":"base.dists.levy.quantile","@stdlib/stats/base/dists/levy/stdev":"base.dists.levy.stdev","@stdlib/stats/base/dists/levy/variance":"base.dists.levy.variance","@stdlib/stats/base/dists/logistic/cdf":"base.dists.logistic.cdf","@stdlib/stats/base/dists/logistic/entropy":"base.dists.logistic.entropy","@stdlib/stats/base/dists/logistic/kurtosis":"base.dists.logistic.kurtosis","@stdlib/stats/base/dists/logistic/logcdf":"base.dists.logistic.logcdf","@stdlib/stats/base/dists/logistic/ctor":"base.dists.logistic.Logistic","@stdlib/stats/base/dists/logistic/logpdf":"base.dists.logistic.logpdf","@stdlib/stats/base/dists/logistic/mean":"base.dists.logistic.mean","@stdlib/stats/base/dists/logistic/median":"base.dists.logistic.median","@stdlib/stats/base/dists/logistic/mgf":"base.dists.logistic.mgf","@stdlib/stats/base/dists/logistic/mode":"base.dists.logistic.mode","@stdlib/stats/base/dists/logistic/pdf":"base.dists.logistic.pdf","@stdlib/stats/base/dists/logistic/quantile":"base.dists.logistic.quantile","@stdlib/stats/base/dists/logistic/skewness":"base.dists.logistic.skewness","@stdlib/stats/base/dists/logistic/stdev":"base.dists.logistic.stdev","@stdlib/stats/base/dists/logistic/variance":"base.dists.logistic.variance","@stdlib/stats/base/dists/lognormal/cdf":"base.dists.lognormal.cdf","@stdlib/stats/base/dists/lognormal/entropy":"base.dists.lognormal.entropy","@stdlib/stats/base/dists/lognormal/kurtosis":"base.dists.lognormal.kurtosis","@stdlib/stats/base/dists/lognormal/ctor":"base.dists.lognormal.LogNormal","@stdlib/stats/base/dists/lognormal/logpdf":"base.dists.lognormal.logpdf","@stdlib/stats/base/dists/lognormal/mean":"base.dists.lognormal.mean","@stdlib/stats/base/dists/lognormal/median":"base.dists.lognormal.median","@stdlib/stats/base/dists/lognormal/mode":"base.dists.lognormal.mode","@stdlib/stats/base/dists/lognormal/pdf":"base.dists.lognormal.pdf","@stdlib/stats/base/dists/lognormal/quantile":"base.dists.lognormal.quantile","@stdlib/stats/base/dists/lognormal/skewness":"base.dists.lognormal.skewness","@stdlib/stats/base/dists/lognormal/stdev":"base.dists.lognormal.stdev","@stdlib/stats/base/dists/lognormal/variance":"base.dists.lognormal.variance","@stdlib/stats/base/dists/negative-binomial/cdf":"base.dists.negativeBinomial.cdf","@stdlib/stats/base/dists/negative-binomial/kurtosis":"base.dists.negativeBinomial.kurtosis","@stdlib/stats/base/dists/negative-binomial/logpmf":"base.dists.negativeBinomial.logpmf","@stdlib/stats/base/dists/negative-binomial/mean":"base.dists.negativeBinomial.mean","@stdlib/stats/base/dists/negative-binomial/mgf":"base.dists.negativeBinomial.mgf","@stdlib/stats/base/dists/negative-binomial/mode":"base.dists.negativeBinomial.mode","@stdlib/stats/base/dists/negative-binomial/ctor":"base.dists.negativeBinomial.NegativeBinomial","@stdlib/stats/base/dists/negative-binomial/pmf":"base.dists.negativeBinomial.pmf","@stdlib/stats/base/dists/negative-binomial/quantile":"base.dists.negativeBinomial.quantile","@stdlib/stats/base/dists/negative-binomial/skewness":"base.dists.negativeBinomial.skewness","@stdlib/stats/base/dists/negative-binomial/stdev":"base.dists.negativeBinomial.stdev","@stdlib/stats/base/dists/negative-binomial/variance":"base.dists.negativeBinomial.variance","@stdlib/stats/base/dists/normal/cdf":"base.dists.normal.cdf","@stdlib/stats/base/dists/normal/entropy":"base.dists.normal.entropy","@stdlib/stats/base/dists/normal/kurtosis":"base.dists.normal.kurtosis","@stdlib/stats/base/dists/normal/logpdf":"base.dists.normal.logpdf","@stdlib/stats/base/dists/normal/mean":"base.dists.normal.mean","@stdlib/stats/base/dists/normal/median":"base.dists.normal.median","@stdlib/stats/base/dists/normal/mgf":"base.dists.normal.mgf","@stdlib/stats/base/dists/normal/mode":"base.dists.normal.mode","@stdlib/stats/base/dists/normal/ctor":"base.dists.normal.Normal","@stdlib/stats/base/dists/normal/pdf":"base.dists.normal.pdf","@stdlib/stats/base/dists/normal/quantile":"base.dists.normal.quantile","@stdlib/stats/base/dists/normal/skewness":"base.dists.normal.skewness","@stdlib/stats/base/dists/normal/stdev":"base.dists.normal.stdev","@stdlib/stats/base/dists/normal/variance":"base.dists.normal.variance","@stdlib/stats/base/dists/pareto-type1/cdf":"base.dists.pareto1.cdf","@stdlib/stats/base/dists/pareto-type1/entropy":"base.dists.pareto1.entropy","@stdlib/stats/base/dists/pareto-type1/kurtosis":"base.dists.pareto1.kurtosis","@stdlib/stats/base/dists/pareto-type1/logcdf":"base.dists.pareto1.logcdf","@stdlib/stats/base/dists/pareto-type1/logpdf":"base.dists.pareto1.logpdf","@stdlib/stats/base/dists/pareto-type1/mean":"base.dists.pareto1.mean","@stdlib/stats/base/dists/pareto-type1/median":"base.dists.pareto1.median","@stdlib/stats/base/dists/pareto-type1/mode":"base.dists.pareto1.mode","@stdlib/stats/base/dists/pareto-type1/ctor":"base.dists.pareto1.Pareto1","@stdlib/stats/base/dists/pareto-type1/pdf":"base.dists.pareto1.pdf","@stdlib/stats/base/dists/pareto-type1/quantile":"base.dists.pareto1.quantile","@stdlib/stats/base/dists/pareto-type1/skewness":"base.dists.pareto1.skewness","@stdlib/stats/base/dists/pareto-type1/variance":"base.dists.pareto1.variance","@stdlib/stats/base/dists/poisson/cdf":"base.dists.poisson.cdf","@stdlib/stats/base/dists/poisson/entropy":"base.dists.poisson.entropy","@stdlib/stats/base/dists/poisson/kurtosis":"base.dists.poisson.kurtosis","@stdlib/stats/base/dists/poisson/logpmf":"base.dists.poisson.logpmf","@stdlib/stats/base/dists/poisson/mean":"base.dists.poisson.mean","@stdlib/stats/base/dists/poisson/median":"base.dists.poisson.median","@stdlib/stats/base/dists/poisson/mgf":"base.dists.poisson.mgf","@stdlib/stats/base/dists/poisson/mode":"base.dists.poisson.mode","@stdlib/stats/base/dists/poisson/pmf":"base.dists.poisson.pmf","@stdlib/stats/base/dists/poisson/ctor":"base.dists.poisson.Poisson","@stdlib/stats/base/dists/poisson/quantile":"base.dists.poisson.quantile","@stdlib/stats/base/dists/poisson/skewness":"base.dists.poisson.skewness","@stdlib/stats/base/dists/poisson/stdev":"base.dists.poisson.stdev","@stdlib/stats/base/dists/poisson/variance":"base.dists.poisson.variance","@stdlib/stats/base/dists/rayleigh/cdf":"base.dists.rayleigh.cdf","@stdlib/stats/base/dists/rayleigh/entropy":"base.dists.rayleigh.entropy","@stdlib/stats/base/dists/rayleigh/kurtosis":"base.dists.rayleigh.kurtosis","@stdlib/stats/base/dists/rayleigh/logcdf":"base.dists.rayleigh.logcdf","@stdlib/stats/base/dists/rayleigh/logpdf":"base.dists.rayleigh.logpdf","@stdlib/stats/base/dists/rayleigh/mean":"base.dists.rayleigh.mean","@stdlib/stats/base/dists/rayleigh/median":"base.dists.rayleigh.median","@stdlib/stats/base/dists/rayleigh/mgf":"base.dists.rayleigh.mgf","@stdlib/stats/base/dists/rayleigh/mode":"base.dists.rayleigh.mode","@stdlib/stats/base/dists/rayleigh/pdf":"base.dists.rayleigh.pdf","@stdlib/stats/base/dists/rayleigh/quantile":"base.dists.rayleigh.quantile","@stdlib/stats/base/dists/rayleigh/ctor":"base.dists.rayleigh.Rayleigh","@stdlib/stats/base/dists/rayleigh/skewness":"base.dists.rayleigh.skewness","@stdlib/stats/base/dists/rayleigh/stdev":"base.dists.rayleigh.stdev","@stdlib/stats/base/dists/rayleigh/variance":"base.dists.rayleigh.variance","@stdlib/stats/base/dists/t/cdf":"base.dists.t.cdf","@stdlib/stats/base/dists/t/entropy":"base.dists.t.entropy","@stdlib/stats/base/dists/t/kurtosis":"base.dists.t.kurtosis","@stdlib/stats/base/dists/t/mean":"base.dists.t.mean","@stdlib/stats/base/dists/t/median":"base.dists.t.median","@stdlib/stats/base/dists/t/mode":"base.dists.t.mode","@stdlib/stats/base/dists/t/pdf":"base.dists.t.pdf","@stdlib/stats/base/dists/t/quantile":"base.dists.t.quantile","@stdlib/stats/base/dists/t/skewness":"base.dists.t.skewness","@stdlib/stats/base/dists/t/stdev":"base.dists.t.stdev","@stdlib/stats/base/dists/t/ctor":"base.dists.t.T","@stdlib/stats/base/dists/t/variance":"base.dists.t.variance","@stdlib/stats/base/dists/triangular/cdf":"base.dists.triangular.cdf","@stdlib/stats/base/dists/triangular/entropy":"base.dists.triangular.entropy","@stdlib/stats/base/dists/triangular/kurtosis":"base.dists.triangular.kurtosis","@stdlib/stats/base/dists/triangular/logcdf":"base.dists.triangular.logcdf","@stdlib/stats/base/dists/triangular/logpdf":"base.dists.triangular.logpdf","@stdlib/stats/base/dists/triangular/mean":"base.dists.triangular.mean","@stdlib/stats/base/dists/triangular/median":"base.dists.triangular.median","@stdlib/stats/base/dists/triangular/mgf":"base.dists.triangular.mgf","@stdlib/stats/base/dists/triangular/mode":"base.dists.triangular.mode","@stdlib/stats/base/dists/triangular/pdf":"base.dists.triangular.pdf","@stdlib/stats/base/dists/triangular/quantile":"base.dists.triangular.quantile","@stdlib/stats/base/dists/triangular/skewness":"base.dists.triangular.skewness","@stdlib/stats/base/dists/triangular/stdev":"base.dists.triangular.stdev","@stdlib/stats/base/dists/triangular/ctor":"base.dists.triangular.Triangular","@stdlib/stats/base/dists/triangular/variance":"base.dists.triangular.variance","@stdlib/stats/base/dists/uniform/cdf":"base.dists.uniform.cdf","@stdlib/stats/base/dists/uniform/entropy":"base.dists.uniform.entropy","@stdlib/stats/base/dists/uniform/kurtosis":"base.dists.uniform.kurtosis","@stdlib/stats/base/dists/uniform/logcdf":"base.dists.uniform.logcdf","@stdlib/stats/base/dists/uniform/logpdf":"base.dists.uniform.logpdf","@stdlib/stats/base/dists/uniform/mean":"base.dists.uniform.mean","@stdlib/stats/base/dists/uniform/median":"base.dists.uniform.median","@stdlib/stats/base/dists/uniform/mgf":"base.dists.uniform.mgf","@stdlib/stats/base/dists/uniform/pdf":"base.dists.uniform.pdf","@stdlib/stats/base/dists/uniform/quantile":"base.dists.uniform.quantile","@stdlib/stats/base/dists/uniform/skewness":"base.dists.uniform.skewness","@stdlib/stats/base/dists/uniform/stdev":"base.dists.uniform.stdev","@stdlib/stats/base/dists/uniform/ctor":"base.dists.uniform.Uniform","@stdlib/stats/base/dists/uniform/variance":"base.dists.uniform.variance","@stdlib/stats/base/dists/weibull/cdf":"base.dists.weibull.cdf","@stdlib/stats/base/dists/weibull/entropy":"base.dists.weibull.entropy","@stdlib/stats/base/dists/weibull/kurtosis":"base.dists.weibull.kurtosis","@stdlib/stats/base/dists/weibull/logcdf":"base.dists.weibull.logcdf","@stdlib/stats/base/dists/weibull/logpdf":"base.dists.weibull.logpdf","@stdlib/stats/base/dists/weibull/mean":"base.dists.weibull.mean","@stdlib/stats/base/dists/weibull/median":"base.dists.weibull.median","@stdlib/stats/base/dists/weibull/mgf":"base.dists.weibull.mgf","@stdlib/stats/base/dists/weibull/mode":"base.dists.weibull.mode","@stdlib/stats/base/dists/weibull/pdf":"base.dists.weibull.pdf","@stdlib/stats/base/dists/weibull/quantile":"base.dists.weibull.quantile","@stdlib/stats/base/dists/weibull/skewness":"base.dists.weibull.skewness","@stdlib/stats/base/dists/weibull/stdev":"base.dists.weibull.stdev","@stdlib/stats/base/dists/weibull/variance":"base.dists.weibull.variance","@stdlib/stats/base/dists/weibull/ctor":"base.dists.weibull.Weibull","@stdlib/math/base/special/ellipe":"base.ellipe","@stdlib/math/base/special/ellipk":"base.ellipk","@stdlib/math/base/utils/float64-epsilon-difference":"base.epsdiff","@stdlib/math/base/special/erf":"base.erf","@stdlib/math/base/special/erfc":"base.erfc","@stdlib/math/base/special/erfcinv":"base.erfcinv","@stdlib/math/base/special/erfinv":"base.erfinv","@stdlib/math/base/special/dirichlet-eta":"base.eta","@stdlib/math/base/tools/evalpoly":"base.evalpoly","@stdlib/math/base/tools/evalrational":"base.evalrational","@stdlib/math/base/special/exp":"base.exp","@stdlib/math/base/special/exp2":"base.exp2","@stdlib/math/base/special/exp10":"base.exp10","@stdlib/math/base/special/expit":"base.expit","@stdlib/math/base/special/expm1":"base.expm1","@stdlib/math/base/special/expm1rel":"base.expm1rel","@stdlib/number/float64/base/exponent":"base.exponent","@stdlib/number/float32/base/exponent":"base.exponentf","@stdlib/math/base/special/factorial":"base.factorial","@stdlib/math/base/special/factorialln":"base.factorialln","@stdlib/math/base/special/falling-factorial":"base.fallingFactorial","@stdlib/math/base/special/fibonacci":"base.fibonacci","@stdlib/math/base/special/fibonacci-index":"base.fibonacciIndex","@stdlib/math/base/tools/fibpoly":"base.fibpoly","@stdlib/math/base/special/flipsign":"base.flipsign","@stdlib/number/float32/base/to-int32":"base.float32ToInt32","@stdlib/number/float32/base/to-uint32":"base.float32ToUint32","@stdlib/number/float64/base/to-float32":"base.float64ToFloat32","@stdlib/number/float64/base/to-int32":"base.float64ToInt32","@stdlib/number/float64/base/to-uint32":"base.float64ToUint32","@stdlib/math/base/special/floor":"base.floor","@stdlib/math/base/special/floor2":"base.floor2","@stdlib/math/base/special/floor10":"base.floor10","@stdlib/math/base/special/floorb":"base.floorb","@stdlib/math/base/special/floorn":"base.floorn","@stdlib/math/base/special/floorsd":"base.floorsd","@stdlib/math/base/special/fresnel":"base.fresnel","@stdlib/math/base/special/fresnelc":"base.fresnelc","@stdlib/math/base/special/fresnels":"base.fresnels","@stdlib/math/base/special/frexp":"base.frexp","@stdlib/number/float64/base/from-binary-string":"base.fromBinaryString","@stdlib/number/float32/base/from-binary-string":"base.fromBinaryStringf","@stdlib/number/uint8/base/from-binary-string":"base.fromBinaryStringUint8","@stdlib/number/uint16/base/from-binary-string":"base.fromBinaryStringUint16","@stdlib/number/uint32/base/from-binary-string":"base.fromBinaryStringUint32","@stdlib/number/float32/base/from-word":"base.fromWordf","@stdlib/number/float64/base/from-words":"base.fromWords","@stdlib/math/base/special/gamma":"base.gamma","@stdlib/math/base/special/gamma1pm1":"base.gamma1pm1","@stdlib/math/base/special/gamma-delta-ratio":"base.gammaDeltaRatio","@stdlib/math/base/special/gammainc":"base.gammainc","@stdlib/math/base/special/gammaincinv":"base.gammaincinv","@stdlib/math/base/special/gamma-lanczos-sum":"base.gammaLanczosSum","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":"base.gammaLanczosSumExpGScaled","@stdlib/math/base/special/gammaln":"base.gammaln","@stdlib/blas/base/gasum":"base.gasum","@stdlib/blas/base/gaxpy":"base.gaxpy","@stdlib/math/base/special/gcd":"base.gcd","@stdlib/blas/base/gcopy":"base.gcopy","@stdlib/number/float64/base/get-high-word":"base.getHighWord","@stdlib/number/float64/base/get-low-word":"base.getLowWord","@stdlib/math/base/special/hacovercos":"base.hacovercos","@stdlib/math/base/special/hacoversin":"base.hacoversin","@stdlib/math/base/special/havercos":"base.havercos","@stdlib/math/base/special/haversin":"base.haversin","@stdlib/math/base/special/heaviside":"base.heaviside","@stdlib/math/base/tools/hermitepoly":"base.hermitepoly","@stdlib/math/base/special/hypot":"base.hypot","@stdlib/math/base/special/imul":"base.imul","@stdlib/math/base/special/imuldw":"base.imuldw","@stdlib/number/int32/base/to-uint32":"base.int32ToUint32","@stdlib/math/base/special/inv":"base.inv","@stdlib/math/base/assert/is-even":"base.isEven","@stdlib/math/base/assert/int32-is-even":"base.isEvenInt32","@stdlib/math/base/assert/is-finite":"base.isFinite","@stdlib/math/base/assert/is-infinite":"base.isInfinite","@stdlib/math/base/assert/is-integer":"base.isInteger","@stdlib/math/base/assert/is-nan":"base.isnan","@stdlib/math/base/assert/is-negative-integer":"base.isNegativeInteger","@stdlib/math/base/assert/is-negative-zero":"base.isNegativeZero","@stdlib/math/base/assert/is-nonnegative-integer":"base.isNonNegativeInteger","@stdlib/math/base/assert/is-nonpositive-integer":"base.isNonPositiveInteger","@stdlib/math/base/assert/is-odd":"base.isOdd","@stdlib/math/base/assert/int32-is-odd":"base.isOddInt32","@stdlib/math/base/assert/is-positive-integer":"base.isPositiveInteger","@stdlib/math/base/assert/is-positive-zero":"base.isPositiveZero","@stdlib/math/base/assert/uint32-is-pow2":"base.isPow2Uint32","@stdlib/math/base/assert/is-probability":"base.isProbability","@stdlib/math/base/assert/is-safe-integer":"base.isSafeInteger","@stdlib/math/base/special/kernel-betainc":"base.kernelBetainc","@stdlib/math/base/special/kernel-betaincinv":"base.kernelBetaincinv","@stdlib/math/base/special/kernel-cos":"base.kernelCos","@stdlib/math/base/special/kernel-sin":"base.kernelSin","@stdlib/math/base/special/kernel-tan":"base.kernelTan","@stdlib/math/base/special/kronecker-delta":"base.kroneckerDelta","@stdlib/math/base/special/lcm":"base.lcm","@stdlib/math/base/special/ldexp":"base.ldexp","@stdlib/math/base/special/ln":"base.ln","@stdlib/math/base/special/log":"base.log","@stdlib/math/base/special/log1mexp":"base.log1mexp","@stdlib/math/base/special/log1p":"base.log1p","@stdlib/math/base/special/log1pexp":"base.log1pexp","@stdlib/math/base/special/log2":"base.log2","@stdlib/math/base/special/log10":"base.log10","@stdlib/math/base/special/logaddexp":"base.logaddexp","@stdlib/math/base/special/logit":"base.logit","@stdlib/math/base/special/lucas":"base.lucas","@stdlib/math/base/tools/lucaspoly":"base.lucaspoly","@stdlib/math/base/special/max":"base.max","@stdlib/math/base/special/maxabs":"base.maxabs","@stdlib/math/base/special/min":"base.min","@stdlib/math/base/special/minabs":"base.minabs","@stdlib/math/base/special/minmax":"base.minmax","@stdlib/math/base/special/minmaxabs":"base.minmaxabs","@stdlib/math/base/special/modf":"base.modf","@stdlib/ndarray/base/ctor":"base.ndarray","@stdlib/ndarray/base/memoized-ctor":"base.ndarrayMemoized","@stdlib/math/base/special/negafibonacci":"base.negafibonacci","@stdlib/math/base/special/negalucas":"base.negalucas","@stdlib/math/base/special/nonfibonacci":"base.nonfibonacci","@stdlib/number/float64/base/normalize":"base.normalize","@stdlib/number/float32/base/normalize":"base.normalizef","@stdlib/math/base/tools/normhermitepoly":"base.normhermitepoly","@stdlib/math/base/special/pdiff":"base.pdiff","@stdlib/math/base/special/polygamma":"base.polygamma","@stdlib/math/base/special/pow":"base.pow","@stdlib/math/base/special/powm1":"base.powm1","@stdlib/math/base/special/rad2deg":"base.rad2deg","@stdlib/math/base/special/ramp":"base.ramp","@stdlib/random/base/arcsine":"base.random.arcsine","@stdlib/random/base/bernoulli":"base.random.bernoulli","@stdlib/random/base/beta":"base.random.beta","@stdlib/random/base/betaprime":"base.random.betaprime","@stdlib/random/base/binomial":"base.random.binomial","@stdlib/random/base/box-muller":"base.random.boxMuller","@stdlib/random/base/cauchy":"base.random.cauchy","@stdlib/random/base/chi":"base.random.chi","@stdlib/random/base/chisquare":"base.random.chisquare","@stdlib/random/base/cosine":"base.random.cosine","@stdlib/random/base/discrete-uniform":"base.random.discreteUniform","@stdlib/random/base/erlang":"base.random.erlang","@stdlib/random/base/exponential":"base.random.exponential","@stdlib/random/base/f":"base.random.f","@stdlib/random/base/frechet":"base.random.frechet","@stdlib/random/base/gamma":"base.random.gamma","@stdlib/random/base/geometric":"base.random.geometric","@stdlib/random/base/gumbel":"base.random.gumbel","@stdlib/random/base/hypergeometric":"base.random.hypergeometric","@stdlib/random/base/improved-ziggurat":"base.random.improvedZiggurat","@stdlib/random/base/invgamma":"base.random.invgamma","@stdlib/random/base/kumaraswamy":"base.random.kumaraswamy","@stdlib/random/base/laplace":"base.random.laplace","@stdlib/random/base/levy":"base.random.levy","@stdlib/random/base/logistic":"base.random.logistic","@stdlib/random/base/lognormal":"base.random.lognormal","@stdlib/random/base/minstd":"base.random.minstd","@stdlib/random/base/minstd-shuffle":"base.random.minstdShuffle","@stdlib/random/base/mt19937":"base.random.mt19937","@stdlib/random/base/negative-binomial":"base.random.negativeBinomial","@stdlib/random/base/normal":"base.random.normal","@stdlib/random/base/pareto-type1":"base.random.pareto1","@stdlib/random/base/poisson":"base.random.poisson","@stdlib/random/base/randi":"base.random.randi","@stdlib/random/base/randn":"base.random.randn","@stdlib/random/base/randu":"base.random.randu","@stdlib/random/base/rayleigh":"base.random.rayleigh","@stdlib/random/base/t":"base.random.t","@stdlib/random/base/triangular":"base.random.triangular","@stdlib/random/base/uniform":"base.random.uniform","@stdlib/random/base/weibull":"base.random.weibull","@stdlib/math/base/utils/relative-difference":"base.reldiff","@stdlib/math/base/special/rempio2":"base.rempio2","@stdlib/math/base/special/rising-factorial":"base.risingFactorial","@stdlib/number/uint32/base/rotl":"base.rotl32","@stdlib/number/uint32/base/rotr":"base.rotr32","@stdlib/math/base/special/round":"base.round","@stdlib/math/base/special/round2":"base.round2","@stdlib/math/base/special/round10":"base.round10","@stdlib/math/base/special/roundb":"base.roundb","@stdlib/math/base/special/roundn":"base.roundn","@stdlib/math/base/special/roundsd":"base.roundsd","@stdlib/math/base/special/rsqrt":"base.rsqrt","@stdlib/blas/base/sasum":"base.sasum","@stdlib/blas/base/saxpy":"base.saxpy","@stdlib/blas/base/scopy":"base.scopy","@stdlib/number/float64/base/set-high-word":"base.setHighWord","@stdlib/number/float64/base/set-low-word":"base.setLowWord","@stdlib/math/base/special/sici":"base.sici","@stdlib/number/float64/base/signbit":"base.signbit","@stdlib/number/float32/base/signbit":"base.signbitf","@stdlib/number/float32/base/significand":"base.significandf","@stdlib/math/base/special/signum":"base.signum","@stdlib/math/base/special/sin":"base.sin","@stdlib/math/base/special/sinc":"base.sinc","@stdlib/math/base/special/sincos":"base.sincos","@stdlib/math/base/special/sincospi":"base.sincospi","@stdlib/math/base/special/sinh":"base.sinh","@stdlib/math/base/special/sinpi":"base.sinpi","@stdlib/math/base/special/spence":"base.spence","@stdlib/math/base/special/sqrt":"base.sqrt","@stdlib/math/base/special/sqrt1pm1":"base.sqrt1pm1","@stdlib/math/base/tools/sum-series":"base.sumSeries","@stdlib/math/base/special/tan":"base.tan","@stdlib/math/base/special/tanh":"base.tanh","@stdlib/number/float64/base/to-binary-string":"base.toBinaryString","@stdlib/number/float32/base/to-binary-string":"base.toBinaryStringf","@stdlib/number/uint8/base/to-binary-string":"base.toBinaryStringUint8","@stdlib/number/uint16/base/to-binary-string":"base.toBinaryStringUint16","@stdlib/number/uint32/base/to-binary-string":"base.toBinaryStringUint32","@stdlib/number/float32/base/to-word":"base.toWordf","@stdlib/number/float64/base/to-words":"base.toWords","@stdlib/math/base/special/trigamma":"base.trigamma","@stdlib/math/base/special/trunc":"base.trunc","@stdlib/math/base/special/trunc2":"base.trunc2","@stdlib/math/base/special/trunc10":"base.trunc10","@stdlib/math/base/special/truncb":"base.truncb","@stdlib/math/base/special/truncn":"base.truncn","@stdlib/math/base/special/truncsd":"base.truncsd","@stdlib/math/base/special/uimul":"base.uimul","@stdlib/math/base/special/uimuldw":"base.uimuldw","@stdlib/number/uint32/base/to-int32":"base.uint32ToInt32","@stdlib/math/base/special/vercos":"base.vercos","@stdlib/math/base/special/versin":"base.versin","@stdlib/math/base/special/wrap":"base.wrap","@stdlib/math/base/special/xlog1py":"base.xlog1py","@stdlib/math/base/special/xlogy":"base.xlogy","@stdlib/math/base/special/riemann-zeta":"base.zeta","@stdlib/datasets/berndt-cps-wages-1985":"BERNDT_CPS_WAGES_1985","@stdlib/utils/bifurcate":"bifurcate","@stdlib/utils/bifurcate-by":"bifurcateBy","@stdlib/utils/async/bifurcate-by":"bifurcateByAsync","@stdlib/utils/bifurcate-in":"bifurcateIn","@stdlib/utils/bifurcate-own":"bifurcateOwn","@stdlib/stats/binomial-test":"binomialTest","@stdlib/buffer/ctor":"Buffer","@stdlib/buffer/to-json":"buffer2json","@stdlib/string/capitalize":"capitalize","@stdlib/utils/capitalize-keys":"capitalizeKeys","@stdlib/constants/math/float64-catalan":"CATALAN","@stdlib/constants/math/float64-cbrt-eps":"CBRT_EPS","@stdlib/process/chdir":"chdir","@stdlib/stats/chi2gof":"chi2gof","@stdlib/array/to-circular-iterator":"circarray2iterator","@stdlib/streams/node/from-circular-array":"circularArrayStream","@stdlib/utils/circular-buffer":"CircularBuffer","@stdlib/datasets/cmudict":"CMUDICT","@stdlib/complex/cmplx":"complex","@stdlib/complex/float32":"Complex64","@stdlib/constants/math/complex64-num-bytes":"COMPLEX64_NUM_BYTES","@stdlib/array/complex64":"Complex64Array","@stdlib/complex/float64":"Complex128","@stdlib/constants/math/complex128-num-bytes":"COMPLEX128_NUM_BYTES","@stdlib/array/complex128":"Complex128Array","@stdlib/utils/compose":"compose","@stdlib/utils/async/compose":"composeAsync","@stdlib/os/configdir":"configdir","@stdlib/complex/conj":"conj","@stdlib/utils/constant-function":"constantFunction","@stdlib/streams/node/from-constant":"constantStream","@stdlib/utils/constructor-name":"constructorName","@stdlib/assert/contains":"contains","@stdlib/array/convert":"convertArray","@stdlib/array/convert-same":"convertArraySame","@stdlib/utils/convert-path":"convertPath","@stdlib/utils/copy":"copy","@stdlib/buffer/from-buffer":"copyBuffer","@stdlib/utils/count-by":"countBy","@stdlib/utils/async/count-by":"countByAsync","@stdlib/utils/curry":"curry","@stdlib/utils/curry-right":"curryRight","@stdlib/process/cwd":"cwd","@stdlib/datasets/dale-chall-new":"DALE_CHALL_NEW","@stdlib/datasets":"datasets","@stdlib/time/day-of-quarter":"dayOfQuarter","@stdlib/time/day-of-year":"dayOfYear","@stdlib/time/days-in-month":"daysInMonth","@stdlib/time/days-in-year":"daysInYear","@stdlib/streams/node/debug-sink":"debugSinkStream","@stdlib/streams/node/debug":"debugStream","@stdlib/assert/deep-equal":"deepEqual","@stdlib/utils/deep-get":"deepGet","@stdlib/assert/deep-has-own-property":"deepHasOwnProp","@stdlib/assert/deep-has-property":"deepHasProp","@stdlib/utils/deep-pluck":"deepPluck","@stdlib/utils/deep-set":"deepSet","@stdlib/utils/define-memoized-property":"defineMemoizedProperty","@stdlib/utils/define-properties":"defineProperties","@stdlib/utils/define-property":"defineProperty","@stdlib/utils/dirname":"dirname","@stdlib/utils/doubly-linked-list":"DoublyLinkedList","@stdlib/utils/do-until":"doUntil","@stdlib/utils/async/do-until":"doUntilAsync","@stdlib/utils/do-until-each":"doUntilEach","@stdlib/utils/do-until-each-right":"doUntilEachRight","@stdlib/utils/do-while":"doWhile","@stdlib/utils/async/do-while":"doWhileAsync","@stdlib/utils/do-while-each":"doWhileEach","@stdlib/utils/do-while-each-right":"doWhileEachRight","@stdlib/constants/math/float64-e":"E","@stdlib/streams/node/empty":"emptyStream","@stdlib/string/ends-with":"endsWith","@stdlib/utils/enumerable-properties":"enumerableProperties","@stdlib/utils/enumerable-properties-in":"enumerablePropertiesIn","@stdlib/utils/enumerable-property-symbols":"enumerablePropertySymbols","@stdlib/utils/enumerable-property-symbols-in":"enumerablePropertySymbolsIn","@stdlib/process/env":"ENV","@stdlib/constants/math/float64-eps":"EPS","@stdlib/error/to-json":"error2json","@stdlib/constants/math/float64-eulergamma":"EULERGAMMA","@stdlib/utils/every":"every","@stdlib/utils/every-by":"everyBy","@stdlib/utils/async/every-by":"everyByAsync","@stdlib/utils/every-by-right":"everyByRight","@stdlib/utils/async/every-by-right":"everyByRightAsync","@stdlib/utils/eval":"evil","@stdlib/fs/exists":"exists","@stdlib/nlp/expand-contractions":"expandContractions","@stdlib/utils/extname":"extname","@stdlib/fastmath/special/abs":"fastmath.abs","@stdlib/fastmath/special/acosh":"fastmath.acosh","@stdlib/fastmath/special/alpha-max-plus-beta-min":"fastmath.ampbm","@stdlib/fastmath/special/asinh":"fastmath.asinh","@stdlib/fastmath/special/atanh":"fastmath.atanh","@stdlib/fastmath/special/hypot":"fastmath.hypot","@stdlib/fastmath/special/uint32-log2":"fastmath.log2Uint32","@stdlib/fastmath/special/max":"fastmath.max","@stdlib/fastmath/special/min":"fastmath.min","@stdlib/fastmath/special/pow-int":"fastmath.powint","@stdlib/fastmath/special/uint32-sqrt":"fastmath.sqrtUint32","@stdlib/datasets/female-first-names-en":"FEMALE_FIRST_NAMES_EN","@stdlib/utils/fifo":"FIFO","@stdlib/utils/find":"find","@stdlib/utils/flatten-array":"flattenArray","@stdlib/utils/flatten-object":"flattenObject","@stdlib/stats/fligner-test":"flignerTest","@stdlib/constants/math/float16-cbrt-eps":"FLOAT16_CBRT_EPS","@stdlib/constants/math/float16-eps":"FLOAT16_EPS","@stdlib/constants/math/float16-exponent-bias":"FLOAT16_EXPONENT_BIAS","@stdlib/constants/math/float16-max":"FLOAT16_MAX","@stdlib/constants/math/float16-max-safe-integer":"FLOAT16_MAX_SAFE_INTEGER","@stdlib/constants/math/float16-min-safe-integer":"FLOAT16_MIN_SAFE_INTEGER","@stdlib/constants/math/float16-ninf":"FLOAT16_NINF","@stdlib/constants/math/float16-num-bytes":"FLOAT16_NUM_BYTES","@stdlib/constants/math/float16-pinf":"FLOAT16_PINF","@stdlib/constants/math/float16-precision":"FLOAT16_PRECISION","@stdlib/constants/math/float16-smallest-normal":"FLOAT16_SMALLEST_NORMAL","@stdlib/constants/math/float16-smallest-subnormal":"FLOAT16_SMALLEST_SUBNORMAL","@stdlib/constants/math/float16-sqrt-eps":"FLOAT16_SQRT_EPS","@stdlib/constants/math/float32-cbrt-eps":"FLOAT32_CBRT_EPS","@stdlib/constants/math/float32-eps":"FLOAT32_EPS","@stdlib/constants/math/float32-exponent-bias":"FLOAT32_EXPONENT_BIAS","@stdlib/constants/math/float32-max":"FLOAT32_MAX","@stdlib/constants/math/float32-max-safe-integer":"FLOAT32_MAX_SAFE_INTEGER","@stdlib/constants/math/float32-min-safe-integer":"FLOAT32_MIN_SAFE_INTEGER","@stdlib/constants/math/float32-ninf":"FLOAT32_NINF","@stdlib/constants/math/float32-num-bytes":"FLOAT32_NUM_BYTES","@stdlib/constants/math/float32-pinf":"FLOAT32_PINF","@stdlib/constants/math/float32-precision":"FLOAT32_PRECISION","@stdlib/constants/math/float32-smallest-normal":"FLOAT32_SMALLEST_NORMAL","@stdlib/constants/math/float32-smallest-subnormal":"FLOAT32_SMALLEST_SUBNORMAL","@stdlib/constants/math/float32-sqrt-eps":"FLOAT32_SQRT_EPS","@stdlib/array/float32":"Float32Array","@stdlib/constants/math/float64-exponent-bias":"FLOAT64_EXPONENT_BIAS","@stdlib/constants/math/float64-high-word-exponent-mask":"FLOAT64_HIGH_WORD_EXPONENT_MASK","@stdlib/constants/math/float64-high-word-significand-mask":"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK","@stdlib/constants/math/float64-max":"FLOAT64_MAX","@stdlib/constants/math/float64-max-base2-exponent":"FLOAT64_MAX_BASE2_EXPONENT","@stdlib/constants/math/float64-max-base2-exponent-subnormal":"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/math/float64-max-base10-exponent":"FLOAT64_MAX_BASE10_EXPONENT","@stdlib/constants/math/float64-max-base10-exponent-subnormal":"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/math/float64-max-ln":"FLOAT64_MAX_LN","@stdlib/constants/math/float64-max-safe-fibonacci":"FLOAT64_MAX_SAFE_FIBONACCI","@stdlib/constants/math/float64-max-safe-integer":"FLOAT64_MAX_SAFE_INTEGER","@stdlib/constants/math/float64-max-safe-lucas":"FLOAT64_MAX_SAFE_LUCAS","@stdlib/constants/math/float64-max-safe-nth-fibonacci":"FLOAT64_MAX_SAFE_NTH_FIBONACCI","@stdlib/constants/math/float64-max-safe-nth-lucas":"FLOAT64_MAX_SAFE_NTH_LUCAS","@stdlib/constants/math/float64-min-base2-exponent":"FLOAT64_MIN_BASE2_EXPONENT","@stdlib/constants/math/float64-min-base2-exponent-subnormal":"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL","@stdlib/constants/math/float64-min-base10-exponent":"FLOAT64_MIN_BASE10_EXPONENT","@stdlib/constants/math/float64-min-base10-exponent-subnormal":"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL","@stdlib/constants/math/float64-min-ln":"FLOAT64_MIN_LN","@stdlib/constants/math/float64-min-safe-integer":"FLOAT64_MIN_SAFE_INTEGER","@stdlib/constants/math/float64-num-bytes":"FLOAT64_NUM_BYTES","@stdlib/constants/math/float64-precision":"FLOAT64_PRECISION","@stdlib/constants/math/float64-smallest-normal":"FLOAT64_SMALLEST_NORMAL","@stdlib/constants/math/float64-smallest-subnormal":"FLOAT64_SMALLEST_SUBNORMAL","@stdlib/array/float64":"Float64Array","@stdlib/utils/for-each":"forEach","@stdlib/utils/async/for-each":"forEachAsync","@stdlib/utils/for-each-right":"forEachRight","@stdlib/utils/async/for-each-right":"forEachRightAsync","@stdlib/utils/for-in":"forIn","@stdlib/utils/for-own":"forOwn","@stdlib/constants/math/float64-fourth-pi":"FOURTH_PI","@stdlib/constants/math/float64-fourth-root-eps":"FOURTH_ROOT_EPS","@stdlib/datasets/frb-sf-wage-rigidity":"FRB_SF_WAGE_RIGIDITY","@stdlib/string/from-code-point":"fromCodePoint","@stdlib/utils/function-name":"functionName","@stdlib/utils/function-sequence":"functionSequence","@stdlib/utils/async/function-sequence":"functionSequenceAsync","@stdlib/constants/math/float64-gamma-lanczos-g":"GAMMA_LANCZOS_G","@stdlib/process/getegid":"getegid","@stdlib/process/geteuid":"geteuid","@stdlib/process/getgid":"getgid","@stdlib/utils/global":"getGlobal","@stdlib/utils/get-prototype-of":"getPrototypeOf","@stdlib/process/getuid":"getuid","@stdlib/constants/math/float64-glaisher-kinkelin":"GLAISHER","@stdlib/utils/group":"group","@stdlib/utils/group-by":"groupBy","@stdlib/utils/async/group-by":"groupByAsync","@stdlib/utils/group-in":"groupIn","@stdlib/utils/group-own":"groupOwn","@stdlib/constants/math/float64-half-ln-two":"HALF_LN2","@stdlib/constants/math/float64-half-pi":"HALF_PI","@stdlib/datasets/harrison-boston-house-prices":"HARRISON_BOSTON_HOUSE_PRICES","@stdlib/datasets/harrison-boston-house-prices-corrected":"HARRISON_BOSTON_HOUSE_PRICES_CORRECTED","@stdlib/assert/has-arraybuffer-support":"hasArrayBufferSupport","@stdlib/assert/has-async-await-support":"hasAsyncAwaitSupport","@stdlib/assert/has-async-iterator-symbol-support":"hasAsyncIteratorSymbolSupport","@stdlib/assert/has-class-support":"hasClassSupport","@stdlib/assert/has-define-properties-support":"hasDefinePropertiesSupport","@stdlib/assert/has-define-property-support":"hasDefinePropertySupport","@stdlib/assert/has-float32array-support":"hasFloat32ArraySupport","@stdlib/assert/has-float64array-support":"hasFloat64ArraySupport","@stdlib/assert/has-function-name-support":"hasFunctionNameSupport","@stdlib/assert/has-generator-support":"hasGeneratorSupport","@stdlib/assert/has-int8array-support":"hasInt8ArraySupport","@stdlib/assert/has-int16array-support":"hasInt16ArraySupport","@stdlib/assert/has-int32array-support":"hasInt32ArraySupport","@stdlib/assert/has-iterator-symbol-support":"hasIteratorSymbolSupport","@stdlib/assert/has-map-support":"hasMapSupport","@stdlib/assert/has-node-buffer-support":"hasNodeBufferSupport","@stdlib/assert/has-own-property":"hasOwnProp","@stdlib/assert/has-property":"hasProp","@stdlib/assert/has-proxy-support":"hasProxySupport","@stdlib/assert/has-set-support":"hasSetSupport","@stdlib/assert/has-sharedarraybuffer-support":"hasSharedArrayBufferSupport","@stdlib/assert/has-symbol-support":"hasSymbolSupport","@stdlib/assert/has-tostringtag-support":"hasToStringTagSupport","@stdlib/assert/has-uint8array-support":"hasUint8ArraySupport","@stdlib/assert/has-uint8clampedarray-support":"hasUint8ClampedArraySupport","@stdlib/assert/has-uint16array-support":"hasUint16ArraySupport","@stdlib/assert/has-uint32array-support":"hasUint32ArraySupport","@stdlib/assert/has-weakmap-support":"hasWeakMapSupport","@stdlib/assert/has-weakset-support":"hasWeakSetSupport","@stdlib/assert/has-wasm-support":"hasWebAssemblySupport","@stdlib/datasets/herndon-venus-semidiameters":"HERNDON_VENUS_SEMIDIAMETERS","@stdlib/os/homedir":"homedir","@stdlib/constants/time/hours-in-day":"HOURS_IN_DAY","@stdlib/constants/time/hours-in-week":"HOURS_IN_WEEK","@stdlib/time/hours-in-month":"hoursInMonth","@stdlib/time/hours-in-year":"hoursInYear","@stdlib/net/http-server":"httpServer","@stdlib/utils/identity-function":"identity","@stdlib/utils/if-else":"ifelse","@stdlib/utils/async/if-else":"ifelseAsync","@stdlib/utils/if-then":"ifthen","@stdlib/utils/async/if-then":"ifthenAsync","@stdlib/complex/imag":"imag","@stdlib/datasets/img-acanthus-mollis":"IMG_ACANTHUS_MOLLIS","@stdlib/datasets/img-airplane-from-above":"IMG_AIRPLANE_FROM_ABOVE","@stdlib/datasets/img-allium-oreophilum":"IMG_ALLIUM_OREOPHILUM","@stdlib/datasets/img-black-canyon":"IMG_BLACK_CANYON","@stdlib/datasets/img-dust-bowl-home":"IMG_DUST_BOWL_HOME","@stdlib/datasets/img-french-alpine-landscape":"IMG_FRENCH_ALPINE_LANDSCAPE","@stdlib/datasets/img-locomotion-house-cat":"IMG_LOCOMOTION_HOUSE_CAT","@stdlib/datasets/img-locomotion-nude-male":"IMG_LOCOMOTION_NUDE_MALE","@stdlib/datasets/img-march-pastoral":"IMG_MARCH_PASTORAL","@stdlib/datasets/img-nagasaki-boats":"IMG_NAGASAKI_BOATS","@stdlib/stats/incr/apcorr":"incrapcorr","@stdlib/stats/incr/count":"incrcount","@stdlib/stats/incr/covariance":"incrcovariance","@stdlib/stats/incr/covmat":"incrcovmat","@stdlib/stats/incr/cv":"incrcv","@stdlib/stats/incr/ewmean":"increwmean","@stdlib/stats/incr/ewstdev":"increwstdev","@stdlib/stats/incr/ewvariance":"increwvariance","@stdlib/stats/incr/gmean":"incrgmean","@stdlib/stats/incr/grubbs":"incrgrubbs","@stdlib/stats/incr/hmean":"incrhmean","@stdlib/ml/incr/kmeans":"incrkmeans","@stdlib/stats/incr/kurtosis":"incrkurtosis","@stdlib/stats/incr/maape":"incrmaape","@stdlib/stats/incr/mae":"incrmae","@stdlib/stats/incr/mapcorr":"incrmapcorr","@stdlib/stats/incr/mape":"incrmape","@stdlib/stats/incr/max":"incrmax","@stdlib/stats/incr/maxabs":"incrmaxabs","@stdlib/stats/incr/mcovariance":"incrmcovariance","@stdlib/stats/incr/mcv":"incrmcv","@stdlib/stats/incr/mda":"incrmda","@stdlib/stats/incr/me":"incrme","@stdlib/stats/incr/mean":"incrmean","@stdlib/stats/incr/meanabs":"incrmeanabs","@stdlib/stats/incr/meanabs2":"incrmeanabs2","@stdlib/stats/incr/meanstdev":"incrmeanstdev","@stdlib/stats/incr/meanvar":"incrmeanvar","@stdlib/stats/incr/mgmean":"incrmgmean","@stdlib/stats/incr/mgrubbs":"incrmgrubbs","@stdlib/stats/incr/mhmean":"incrmhmean","@stdlib/stats/incr/midrange":"incrmidrange","@stdlib/stats/incr/min":"incrmin","@stdlib/stats/incr/minabs":"incrminabs","@stdlib/stats/incr/minmax":"incrminmax","@stdlib/stats/incr/minmaxabs":"incrminmaxabs","@stdlib/stats/incr/mmaape":"incrmmaape","@stdlib/stats/incr/mmae":"incrmmae","@stdlib/stats/incr/mmape":"incrmmape","@stdlib/stats/incr/mmax":"incrmmax","@stdlib/stats/incr/mmaxabs":"incrmmaxabs","@stdlib/stats/incr/mmda":"incrmmda","@stdlib/stats/incr/mme":"incrmme","@stdlib/stats/incr/mmean":"incrmmean","@stdlib/stats/incr/mmeanabs":"incrmmeanabs","@stdlib/stats/incr/mmeanabs2":"incrmmeanabs2","@stdlib/stats/incr/mmeanstdev":"incrmmeanstdev","@stdlib/stats/incr/mmeanvar":"incrmmeanvar","@stdlib/stats/incr/mmidrange":"incrmmidrange","@stdlib/stats/incr/mmin":"incrmmin","@stdlib/stats/incr/mminabs":"incrmminabs","@stdlib/stats/incr/mminmax":"incrmminmax","@stdlib/stats/incr/mminmaxabs":"incrmminmaxabs","@stdlib/stats/incr/mmpe":"incrmmpe","@stdlib/stats/incr/mmse":"incrmmse","@stdlib/stats/incr/mpcorr":"incrmpcorr","@stdlib/stats/incr/mpcorr2":"incrmpcorr2","@stdlib/stats/incr/mpcorrdist":"incrmpcorrdist","@stdlib/stats/incr/mpe":"incrmpe","@stdlib/stats/incr/mprod":"incrmprod","@stdlib/stats/incr/mrange":"incrmrange","@stdlib/stats/incr/mrmse":"incrmrmse","@stdlib/stats/incr/mrss":"incrmrss","@stdlib/stats/incr/mse":"incrmse","@stdlib/stats/incr/mstdev":"incrmstdev","@stdlib/stats/incr/msum":"incrmsum","@stdlib/stats/incr/msumabs":"incrmsumabs","@stdlib/stats/incr/msumabs2":"incrmsumabs2","@stdlib/stats/incr/msummary":"incrmsummary","@stdlib/stats/incr/msumprod":"incrmsumprod","@stdlib/stats/incr/mvariance":"incrmvariance","@stdlib/stats/incr/mvmr":"incrmvmr","@stdlib/stats/incr/pcorr":"incrpcorr","@stdlib/stats/incr/pcorr2":"incrpcorr2","@stdlib/stats/incr/pcorrdist":"incrpcorrdist","@stdlib/stats/incr/pcorrdistmat":"incrpcorrdistmat","@stdlib/stats/incr/pcorrmat":"incrpcorrmat","@stdlib/stats/incr/prod":"incrprod","@stdlib/stats/incr/range":"incrrange","@stdlib/stats/incr/rmse":"incrrmse","@stdlib/stats/incr/rss":"incrrss","@stdlib/stats/incr/skewness":"incrskewness","@stdlib/math/utils/incrspace":"incrspace","@stdlib/stats/incr/stdev":"incrstdev","@stdlib/stats/incr/sum":"incrsum","@stdlib/stats/incr/sumabs":"incrsumabs","@stdlib/stats/incr/sumabs2":"incrsumabs2","@stdlib/stats/incr/summary":"incrsummary","@stdlib/stats/incr/sumprod":"incrsumprod","@stdlib/stats/incr/variance":"incrvariance","@stdlib/stats/incr/vmr":"incrvmr","@stdlib/stats/incr/wmean":"incrwmean","@stdlib/ndarray/ind2sub":"ind2sub","@stdlib/utils/index-of":"indexOf","@stdlib/utils/inherit":"inherit","@stdlib/utils/inherited-enumerable-properties":"inheritedEnumerableProperties","@stdlib/utils/inherited-enumerable-property-symbols":"inheritedEnumerablePropertySymbols","@stdlib/utils/inherited-keys":"inheritedKeys","@stdlib/utils/inherited-nonenumerable-properties":"inheritedNonEnumerableProperties","@stdlib/utils/inherited-nonenumerable-property-names":"inheritedNonEnumerablePropertyNames","@stdlib/utils/inherited-nonenumerable-property-symbols":"inheritedNonEnumerablePropertySymbols","@stdlib/utils/inherited-properties":"inheritedProperties","@stdlib/utils/inherited-property-descriptor":"inheritedPropertyDescriptor","@stdlib/utils/inherited-property-descriptors":"inheritedPropertyDescriptors","@stdlib/utils/inherited-property-names":"inheritedPropertyNames","@stdlib/utils/inherited-property-symbols":"inheritedPropertySymbols","@stdlib/utils/inherited-writable-properties":"inheritedWritableProperties","@stdlib/utils/inherited-writable-property-names":"inheritedWritablePropertyNames","@stdlib/utils/inherited-writable-property-symbols":"inheritedWritablePropertySymbols","@stdlib/utils/inmap":"inmap","@stdlib/utils/async/inmap":"inmapAsync","@stdlib/utils/inmap-right":"inmapRight","@stdlib/utils/async/inmap-right":"inmapRightAsync","@stdlib/streams/node/inspect-sink":"inspectSinkStream","@stdlib/streams/node/inspect":"inspectStream","@stdlib/assert/instance-of":"instanceOf","@stdlib/constants/math/int8-max":"INT8_MAX","@stdlib/constants/math/int8-min":"INT8_MIN","@stdlib/constants/math/int8-num-bytes":"INT8_NUM_BYTES","@stdlib/array/int8":"Int8Array","@stdlib/constants/math/int16-max":"INT16_MAX","@stdlib/constants/math/int16-min":"INT16_MIN","@stdlib/constants/math/int16-num-bytes":"INT16_NUM_BYTES","@stdlib/array/int16":"Int16Array","@stdlib/constants/math/int32-max":"INT32_MAX","@stdlib/constants/math/int32-min":"INT32_MIN","@stdlib/constants/math/int32-num-bytes":"INT32_NUM_BYTES","@stdlib/array/int32":"Int32Array","@stdlib/assert/is-big-endian":"IS_BIG_ENDIAN","@stdlib/assert/is-browser":"IS_BROWSER","@stdlib/assert/is-darwin":"IS_DARWIN","@stdlib/assert/is-electron":"IS_ELECTRON","@stdlib/assert/is-electron-main":"IS_ELECTRON_MAIN","@stdlib/assert/is-electron-renderer":"IS_ELECTRON_RENDERER","@stdlib/assert/is-little-endian":"IS_LITTLE_ENDIAN","@stdlib/assert/is-node":"IS_NODE","@stdlib/assert/is-web-worker":"IS_WEB_WORKER","@stdlib/assert/is-windows":"IS_WINDOWS","@stdlib/assert/is-absolute-path":"isAbsolutePath","@stdlib/assert/is-accessor-property":"isAccessorProperty","@stdlib/assert/is-accessor-property-in":"isAccessorPropertyIn","@stdlib/assert/is-alphagram":"isAlphagram","@stdlib/assert/is-alphanumeric":"isAlphaNumeric","@stdlib/assert/is-anagram":"isAnagram","@stdlib/assert/is-arguments":"isArguments","@stdlib/assert/is-array":"isArray","@stdlib/assert/is-array-array":"isArrayArray","@stdlib/assert/is-arraybuffer":"isArrayBuffer","@stdlib/assert/is-array-length":"isArrayLength","@stdlib/assert/is-array-like":"isArrayLike","@stdlib/assert/is-array-like-object":"isArrayLikeObject","@stdlib/assert/is-ascii":"isASCII","@stdlib/assert/is-between":"isBetween","@stdlib/assert/is-between-array":"isBetweenArray","@stdlib/assert/is-binary-string":"isBinaryString","@stdlib/assert/is-boolean":"isBoolean","@stdlib/assert/is-boolean-array":"isBooleanArray","@stdlib/assert/is-boxed-primitive":"isBoxedPrimitive","@stdlib/assert/is-buffer":"isBuffer","@stdlib/assert/is-capitalized":"isCapitalized","@stdlib/assert/is-centrosymmetric-matrix":"isCentrosymmetricMatrix","@stdlib/assert/is-circular":"isCircular","@stdlib/assert/is-circular-array":"isCircularArray","@stdlib/assert/is-circular-plain-object":"isCircularPlainObject","@stdlib/assert/is-collection":"isCollection","@stdlib/assert/is-complex":"isComplex","@stdlib/assert/is-complex64":"isComplex64","@stdlib/assert/is-complex64array":"isComplex64Array","@stdlib/assert/is-complex128":"isComplex128","@stdlib/assert/is-complex128array":"isComplex128Array","@stdlib/assert/is-complex-like":"isComplexLike","@stdlib/assert/is-complex-typed-array":"isComplexTypedArray","@stdlib/assert/is-configurable-property":"isConfigurableProperty","@stdlib/assert/is-configurable-property-in":"isConfigurablePropertyIn","@stdlib/assert/is-data-property":"isDataProperty","@stdlib/assert/is-data-property-in":"isDataPropertyIn","@stdlib/assert/is-date-object":"isDateObject","@stdlib/assert/is-digit-string":"isDigitString","@stdlib/assert/is-email-address":"isEmailAddress","@stdlib/assert/is-empty-array":"isEmptyArray","@stdlib/assert/is-empty-object":"isEmptyObject","@stdlib/assert/is-empty-string":"isEmptyString","@stdlib/assert/is-enumerable-property":"isEnumerableProperty","@stdlib/assert/is-enumerable-property-in":"isEnumerablePropertyIn","@stdlib/assert/is-error":"isError","@stdlib/assert/is-eval-error":"isEvalError","@stdlib/assert/is-even":"isEven","@stdlib/assert/is-falsy":"isFalsy","@stdlib/assert/is-falsy-array":"isFalsyArray","@stdlib/assert/is-finite":"isFinite","@stdlib/assert/is-finite-array":"isFiniteArray","@stdlib/assert/is-float32array":"isFloat32Array","@stdlib/assert/is-float64array":"isFloat64Array","@stdlib/assert/is-function":"isFunction","@stdlib/assert/is-function-array":"isFunctionArray","@stdlib/assert/is-generator-object":"isGeneratorObject","@stdlib/assert/is-generator-object-like":"isGeneratorObjectLike","@stdlib/assert/is-hex-string":"isHexString","@stdlib/assert/is-infinite":"isInfinite","@stdlib/assert/is-inherited-property":"isInheritedProperty","@stdlib/assert/is-int8array":"isInt8Array","@stdlib/assert/is-int16array":"isInt16Array","@stdlib/assert/is-int32array":"isInt32Array","@stdlib/assert/is-integer":"isInteger","@stdlib/assert/is-integer-array":"isIntegerArray","@stdlib/assert/is-iterable-like":"isIterableLike","@stdlib/assert/is-iterator-like":"isIteratorLike","@stdlib/assert/is-json":"isJSON","@stdlib/assert/is-leap-year":"isLeapYear","@stdlib/assert/is-lowercase":"isLowercase","@stdlib/assert/is-matrix-like":"isMatrixLike","@stdlib/assert/is-method":"isMethod","@stdlib/assert/is-method-in":"isMethodIn","@stdlib/assert/is-named-typed-tuple-like":"isNamedTypedTupleLike","@stdlib/assert/is-nan":"isnan","@stdlib/assert/is-nan-array":"isNaNArray","@stdlib/assert/is-native-function":"isNativeFunction","@stdlib/assert/is-ndarray-like":"isndarrayLike","@stdlib/assert/is-negative-integer":"isNegativeInteger","@stdlib/assert/is-negative-integer-array":"isNegativeIntegerArray","@stdlib/assert/is-negative-number":"isNegativeNumber","@stdlib/assert/is-negative-number-array":"isNegativeNumberArray","@stdlib/assert/is-negative-zero":"isNegativeZero","@stdlib/assert/is-node-builtin":"isNodeBuiltin","@stdlib/assert/is-node-duplex-stream-like":"isNodeDuplexStreamLike","@stdlib/assert/is-node-readable-stream-like":"isNodeReadableStreamLike","@stdlib/assert/is-node-repl":"isNodeREPL","@stdlib/assert/is-node-stream-like":"isNodeStreamLike","@stdlib/assert/is-node-transform-stream-like":"isNodeTransformStreamLike","@stdlib/assert/is-node-writable-stream-like":"isNodeWritableStreamLike","@stdlib/assert/is-nonconfigurable-property":"isNonConfigurableProperty","@stdlib/assert/is-nonconfigurable-property-in":"isNonConfigurablePropertyIn","@stdlib/assert/is-nonenumerable-property":"isNonEnumerableProperty","@stdlib/assert/is-nonenumerable-property-in":"isNonEnumerablePropertyIn","@stdlib/assert/is-nonnegative-integer":"isNonNegativeInteger","@stdlib/assert/is-nonnegative-integer-array":"isNonNegativeIntegerArray","@stdlib/assert/is-nonnegative-number":"isNonNegativeNumber","@stdlib/assert/is-nonnegative-number-array":"isNonNegativeNumberArray","@stdlib/assert/is-nonpositive-integer":"isNonPositiveInteger","@stdlib/assert/is-nonpositive-integer-array":"isNonPositiveIntegerArray","@stdlib/assert/is-nonpositive-number":"isNonPositiveNumber","@stdlib/assert/is-nonpositive-number-array":"isNonPositiveNumberArray","@stdlib/assert/is-nonsymmetric-matrix":"isNonSymmetricMatrix","@stdlib/assert/is-null":"isNull","@stdlib/assert/is-null-array":"isNullArray","@stdlib/assert/is-number":"isNumber","@stdlib/assert/is-number-array":"isNumberArray","@stdlib/assert/is-numeric-array":"isNumericArray","@stdlib/assert/is-object":"isObject","@stdlib/assert/is-object-array":"isObjectArray","@stdlib/assert/is-object-like":"isObjectLike","@stdlib/assert/is-odd":"isOdd","@stdlib/time/iso-weeks-in-year":"isoWeeksInYear","@stdlib/assert/is-persymmetric-matrix":"isPersymmetricMatrix","@stdlib/assert/is-plain-object":"isPlainObject","@stdlib/assert/is-plain-object-array":"isPlainObjectArray","@stdlib/assert/is-positive-integer":"isPositiveInteger","@stdlib/assert/is-positive-integer-array":"isPositiveIntegerArray","@stdlib/assert/is-positive-number":"isPositiveNumber","@stdlib/assert/is-positive-number-array":"isPositiveNumberArray","@stdlib/assert/is-positive-zero":"isPositiveZero","@stdlib/assert/is-primitive":"isPrimitive","@stdlib/assert/is-primitive-array":"isPrimitiveArray","@stdlib/assert/is-prng-like":"isPRNGLike","@stdlib/assert/is-probability":"isProbability","@stdlib/assert/is-probability-array":"isProbabilityArray","@stdlib/assert/is-prototype-of":"isPrototypeOf","@stdlib/assert/is-range-error":"isRangeError","@stdlib/assert/is-readable-property":"isReadableProperty","@stdlib/assert/is-readable-property-in":"isReadablePropertyIn","@stdlib/assert/is-read-only-property":"isReadOnlyProperty","@stdlib/assert/is-read-only-property-in":"isReadOnlyPropertyIn","@stdlib/assert/is-read-write-property":"isReadWriteProperty","@stdlib/assert/is-read-write-property-in":"isReadWritePropertyIn","@stdlib/assert/is-reference-error":"isReferenceError","@stdlib/assert/is-regexp":"isRegExp","@stdlib/assert/is-regexp-string":"isRegExpString","@stdlib/assert/is-relative-path":"isRelativePath","@stdlib/assert/is-safe-integer":"isSafeInteger","@stdlib/assert/is-safe-integer-array":"isSafeIntegerArray","@stdlib/assert/is-same-value":"isSameValue","@stdlib/assert/is-same-value-zero":"isSameValueZero","@stdlib/assert/is-sharedarraybuffer":"isSharedArrayBuffer","@stdlib/assert/is-skew-centrosymmetric-matrix":"isSkewCentrosymmetricMatrix","@stdlib/assert/is-skew-persymmetric-matrix":"isSkewPersymmetricMatrix","@stdlib/assert/is-skew-symmetric-matrix":"isSkewSymmetricMatrix","@stdlib/assert/is-square-matrix":"isSquareMatrix","@stdlib/assert/is-strict-equal":"isStrictEqual","@stdlib/assert/is-string":"isString","@stdlib/assert/is-string-array":"isStringArray","@stdlib/assert/is-symbol":"isSymbol","@stdlib/assert/is-symbol-array":"isSymbolArray","@stdlib/assert/is-symmetric-matrix":"isSymmetricMatrix","@stdlib/assert/is-syntax-error":"isSyntaxError","@stdlib/assert/is-truthy":"isTruthy","@stdlib/assert/is-truthy-array":"isTruthyArray","@stdlib/assert/is-typed-array":"isTypedArray","@stdlib/assert/is-typed-array-length":"isTypedArrayLength","@stdlib/assert/is-typed-array-like":"isTypedArrayLike","@stdlib/assert/is-type-error":"isTypeError","@stdlib/assert/is-uint8array":"isUint8Array","@stdlib/assert/is-uint8clampedarray":"isUint8ClampedArray","@stdlib/assert/is-uint16array":"isUint16Array","@stdlib/assert/is-uint32array":"isUint32Array","@stdlib/assert/is-unc-path":"isUNCPath","@stdlib/assert/is-undefined":"isUndefined","@stdlib/assert/is-undefined-or-null":"isUndefinedOrNull","@stdlib/assert/is-unity-probability-array":"isUnityProbabilityArray","@stdlib/assert/is-uppercase":"isUppercase","@stdlib/assert/is-uri":"isURI","@stdlib/assert/is-uri-error":"isURIError","@stdlib/assert/is-vector-like":"isVectorLike","@stdlib/assert/is-whitespace":"isWhitespace","@stdlib/assert/is-writable-property":"isWritableProperty","@stdlib/assert/is-writable-property-in":"isWritablePropertyIn","@stdlib/assert/is-write-only-property":"isWriteOnlyProperty","@stdlib/assert/is-write-only-property-in":"isWriteOnlyPropertyIn","@stdlib/math/iter/add":"iterAdd","@stdlib/iter/advance":"iterAdvance","@stdlib/iter/any":"iterAny","@stdlib/iter/any-by":"iterAnyBy","@stdlib/array/from-iterator":"iterator2array","@stdlib/iter/to-array-view":"iterator2arrayview","@stdlib/iter/to-array-view-right":"iterator2arrayviewRight","@stdlib/streams/node/from-iterator":"iteratorStream","@stdlib/symbol/iterator":"IteratorSymbol","@stdlib/simulate/iter/awgn":"iterawgn","@stdlib/simulate/iter/awln":"iterawln","@stdlib/simulate/iter/awun":"iterawun","@stdlib/simulate/iter/bartlett-hann-pulse":"iterBartlettHannPulse","@stdlib/simulate/iter/bartlett-pulse":"iterBartlettPulse","@stdlib/iter/concat":"iterConcat","@stdlib/iter/constant":"iterConstant","@stdlib/simulate/iter/cosine-wave":"iterCosineWave","@stdlib/iter/counter":"iterCounter","@stdlib/stats/iter/cugmean":"itercugmean","@stdlib/stats/iter/cuhmean":"itercuhmean","@stdlib/stats/iter/cumax":"itercumax","@stdlib/stats/iter/cumaxabs":"itercumaxabs","@stdlib/stats/iter/cumean":"itercumean","@stdlib/stats/iter/cumeanabs":"itercumeanabs","@stdlib/stats/iter/cumeanabs2":"itercumeanabs2","@stdlib/stats/iter/cumidrange":"itercumidrange","@stdlib/stats/iter/cumin":"itercumin","@stdlib/stats/iter/cuminabs":"itercuminabs","@stdlib/stats/iter/cuprod":"itercuprod","@stdlib/stats/iter/curange":"itercurange","@stdlib/stats/iter/cusum":"itercusum","@stdlib/stats/iter/cusumabs":"itercusumabs","@stdlib/stats/iter/cusumabs2":"itercusumabs2","@stdlib/iter/dedupe":"iterDedupe","@stdlib/iter/dedupe-by":"iterDedupeBy","@stdlib/simulate/iter/dirac-comb":"iterDiracComb","@stdlib/math/iter/divide":"iterDivide","@stdlib/iter/empty":"iterEmpty","@stdlib/iter/every":"iterEvery","@stdlib/iter/every-by":"iterEveryBy","@stdlib/math/iter/fibonacci":"iterFibonacci","@stdlib/iter/fill":"iterFill","@stdlib/iter/filter":"iterFilter","@stdlib/iter/filter-map":"iterFilterMap","@stdlib/iter/first":"iterFirst","@stdlib/simulate/iter/flat-top-pulse":"iterFlatTopPulse","@stdlib/iter/flow":"iterFlow","@stdlib/iter/for-each":"iterForEach","@stdlib/simulate/iter/hann-pulse":"iterHannPulse","@stdlib/iter/head":"iterHead","@stdlib/iter/intersection":"iterIntersection","@stdlib/iter/intersection-by-hash":"iterIntersectionByHash","@stdlib/simulate/iter/lanczos-pulse":"iterLanczosPulse","@stdlib/iter/last":"iterLast","@stdlib/iter/length":"iterLength","@stdlib/iter/map":"iterMap","@stdlib/iter/mapn":"iterMapN","@stdlib/stats/iter/max":"itermax","@stdlib/stats/iter/maxabs":"itermaxabs","@stdlib/stats/iter/mean":"itermean","@stdlib/stats/iter/meanabs":"itermeanabs","@stdlib/stats/iter/meanabs2":"itermeanabs2","@stdlib/stats/iter/midrange":"itermidrange","@stdlib/stats/iter/min":"itermin","@stdlib/stats/iter/minabs":"iterminabs","@stdlib/stats/iter/mmax":"itermmax","@stdlib/stats/iter/mmaxabs":"itermmaxabs","@stdlib/stats/iter/mmean":"itermmean","@stdlib/stats/iter/mmeanabs":"itermmeanabs","@stdlib/stats/iter/mmeanabs2":"itermmeanabs2","@stdlib/stats/iter/mmidrange":"itermmidrange","@stdlib/stats/iter/mmin":"itermmin","@stdlib/stats/iter/mminabs":"itermminabs","@stdlib/math/iter/mod":"iterMod","@stdlib/stats/iter/mprod":"itermprod","@stdlib/stats/iter/mrange":"itermrange","@stdlib/stats/iter/msum":"itermsum","@stdlib/stats/iter/msumabs":"itermsumabs","@stdlib/stats/iter/msumabs2":"itermsumabs2","@stdlib/math/iter/multiply":"iterMultiply","@stdlib/iter/none":"iterNone","@stdlib/iter/none-by":"iterNoneBy","@stdlib/math/iter/nonfibonacci":"iterNonFibonacci","@stdlib/iter/nth":"iterNth","@stdlib/simulate/iter/periodic-sinc":"iterPeriodicSinc","@stdlib/iter/pipeline":"iterPipeline","@stdlib/iter/pop":"iterPop","@stdlib/stats/iter/prod":"iterprod","@stdlib/simulate/iter/pulse":"iterPulse","@stdlib/iter/push":"iterPush","@stdlib/stats/iter/range":"iterrange","@stdlib/iter/reject":"iterReject","@stdlib/iter/replicate":"iterReplicate","@stdlib/iter/replicate-by":"iterReplicateBy","@stdlib/simulate/iter/sawtooth-wave":"iterSawtoothWave","@stdlib/iter/shift":"iterShift","@stdlib/simulate/iter/sine-wave":"iterSineWave","@stdlib/iter/slice":"iterSlice","@stdlib/iter/some":"iterSome","@stdlib/iter/some-by":"iterSomeBy","@stdlib/simulate/iter/square-wave":"iterSquareWave","@stdlib/stats/iter/stdev":"iterstdev","@stdlib/math/iter/subtract":"iterSubtract","@stdlib/stats/iter/sum":"itersum","@stdlib/stats/iter/sumabs":"itersumabs","@stdlib/stats/iter/sumabs2":"itersumabs2","@stdlib/iter/pipeline-thunk":"iterThunk","@stdlib/simulate/iter/triangle-wave":"iterTriangleWave","@stdlib/iter/union":"iterUnion","@stdlib/iter/unique":"iterUnique","@stdlib/iter/unique-by":"iterUniqueBy","@stdlib/iter/unique-by-hash":"iterUniqueByHash","@stdlib/iter/unshift":"iterUnshift","@stdlib/stats/iter/variance":"itervariance","@stdlib/streams/node/join":"joinStream","@stdlib/stats/kde2d":"kde2d","@stdlib/utils/key-by":"keyBy","@stdlib/utils/key-by-right":"keyByRight","@stdlib/utils/keys-in":"keysIn","@stdlib/stats/kruskal-test":"kruskalTest","@stdlib/stats/kstest":"kstest","@stdlib/nlp/lda":"lda","@stdlib/utils/linked-list":"LinkedList","@stdlib/math/utils/linspace":"linspace","@stdlib/datasets/liu-negative-opinion-words-en":"LIU_NEGATIVE_OPINION_WORDS_EN","@stdlib/datasets/liu-positive-opinion-words-en":"LIU_POSITIVE_OPINION_WORDS_EN","@stdlib/constants/math/float64-ln-half":"LN_HALF","@stdlib/constants/math/float64-ln-pi":"LN_PI","@stdlib/constants/math/float64-ln-sqrt-two-pi":"LN_SQRT_TWO_PI","@stdlib/constants/math/float64-ln-two-pi":"LN_TWO_PI","@stdlib/constants/math/float64-ln-two":"LN2","@stdlib/constants/math/float64-ln-ten":"LN10","@stdlib/constants/math/float64-log2-e":"LOG2E","@stdlib/constants/math/float64-log10-e":"LOG10E","@stdlib/math/utils/logspace":"logspace","@stdlib/string/lowercase":"lowercase","@stdlib/utils/lowercase-keys":"lowercaseKeys","@stdlib/stats/lowess":"lowess","@stdlib/string/left-pad":"lpad","@stdlib/string/left-trim":"ltrim","@stdlib/datasets/male-first-names-en":"MALE_FIRST_NAMES_EN","@stdlib/utils/map-function":"mapFun","@stdlib/utils/async/map-function":"mapFunAsync","@stdlib/utils/map-keys":"mapKeys","@stdlib/utils/async/map-keys":"mapKeysAsync","@stdlib/utils/map-values":"mapValues","@stdlib/utils/async/map-values":"mapValuesAsync","@stdlib/constants/array/max-array-length":"MAX_ARRAY_LENGTH","@stdlib/constants/array/max-typed-array-length":"MAX_TYPED_ARRAY_LENGTH","@stdlib/utils/memoize":"memoize","@stdlib/utils/merge":"merge","@stdlib/constants/time/milliseconds-in-day":"MILLISECONDS_IN_DAY","@stdlib/constants/time/milliseconds-in-hour":"MILLISECONDS_IN_HOUR","@stdlib/constants/time/milliseconds-in-minute":"MILLISECONDS_IN_MINUTE","@stdlib/constants/time/milliseconds-in-second":"MILLISECONDS_IN_SECOND","@stdlib/constants/time/milliseconds-in-week":"MILLISECONDS_IN_WEEK","@stdlib/datasets/minard-napoleons-march":"MINARD_NAPOLEONS_MARCH","@stdlib/constants/time/minutes-in-day":"MINUTES_IN_DAY","@stdlib/constants/time/minutes-in-hour":"MINUTES_IN_HOUR","@stdlib/constants/time/minutes-in-week":"MINUTES_IN_WEEK","@stdlib/time/minutes-in-month":"minutesInMonth","@stdlib/time/minutes-in-year":"minutesInYear","@stdlib/datasets/moby-dick":"MOBY_DICK","@stdlib/datasets/month-names-en":"MONTH_NAMES_EN","@stdlib/constants/time/months-in-year":"MONTHS_IN_YEAR","@stdlib/utils/move-property":"moveProperty","@stdlib/utils/named-typed-tuple":"namedtypedtuple","@stdlib/utils/native-class":"nativeClass","@stdlib/ndarray/ctor":"ndarray","@stdlib/ndarray/casting-modes":"ndarrayCastingModes","@stdlib/ndarray/dtypes":"ndarrayDataTypes","@stdlib/ndarray/index-modes":"ndarrayIndexModes","@stdlib/ndarray/memoized-ctor":"ndarrayMemoized","@stdlib/ndarray/min-dtype":"ndarrayMinDataType","@stdlib/ndarray/next-dtype":"ndarrayNextDataType","@stdlib/ndarray/orders":"ndarrayOrders","@stdlib/ndarray/promotion-rules":"ndarrayPromotionRules","@stdlib/ndarray/safe-casts":"ndarraySafeCasts","@stdlib/ndarray/same-kind-casts":"ndarraySameKindCasts","@stdlib/datasets/nightingales-rose":"NIGHTINGALES_ROSE","@stdlib/constants/math/float64-ninf":"NINF","@stdlib/process/node-version":"NODE_VERSION","@stdlib/utils/none":"none","@stdlib/utils/none-by":"noneBy","@stdlib/utils/async/none-by":"noneByAsync","@stdlib/utils/none-by-right":"noneByRight","@stdlib/utils/async/none-by-right":"noneByRightAsync","@stdlib/utils/nonenumerable-properties":"nonEnumerableProperties","@stdlib/utils/nonenumerable-properties-in":"nonEnumerablePropertiesIn","@stdlib/utils/nonenumerable-property-names":"nonEnumerablePropertyNames","@stdlib/utils/nonenumerable-property-names-in":"nonEnumerablePropertyNamesIn","@stdlib/utils/nonenumerable-property-symbols":"nonEnumerablePropertySymbols","@stdlib/utils/nonenumerable-property-symbols-in":"nonEnumerablePropertySymbolsIn","@stdlib/utils/noop":"noop","@stdlib/time/now":"now","@stdlib/os/num-cpus":"NUM_CPUS","@stdlib/number/ctor":"Number","@stdlib/utils/entries":"objectEntries","@stdlib/utils/entries-in":"objectEntriesIn","@stdlib/utils/from-entries":"objectFromEntries","@stdlib/utils/object-inverse":"objectInverse","@stdlib/utils/object-inverse-by":"objectInverseBy","@stdlib/utils/keys":"objectKeys","@stdlib/utils/values":"objectValues","@stdlib/utils/values-in":"objectValuesIn","@stdlib/utils/omit":"omit","@stdlib/utils/omit-by":"omitBy","@stdlib/ml/online-binary-classification":"onlineBinaryClassification","@stdlib/ml/online-sgd-regression":"onlineSGDRegression","@stdlib/utils/open-url":"openURL","@stdlib/datasets/pace-boston-house-prices":"PACE_BOSTON_HOUSE_PRICES","@stdlib/string/pad":"pad","@stdlib/utils/papply":"papply","@stdlib/utils/papply-right":"papplyRight","@stdlib/utils/parallel":"parallel","@stdlib/utils/parse-json":"parseJSON","@stdlib/constants/string/path-delimiter":"PATH_DELIMITER","@stdlib/constants/string/path-delimiter-posix":"PATH_DELIMITER_POSIX","@stdlib/constants/string/path-delimiter-win32":"PATH_DELIMITER_WIN32","@stdlib/constants/string/path-sep":"PATH_SEP","@stdlib/constants/string/path-sep-posix":"PATH_SEP_POSIX","@stdlib/constants/string/path-sep-win32":"PATH_SEP_WIN32","@stdlib/stats/pcorrtest":"pcorrtest","@stdlib/string/percent-encode":"percentEncode","@stdlib/constants/math/float64-phi":"PHI","@stdlib/constants/math/float64-pi":"PI","@stdlib/constants/math/float64-pi-squared":"PI_SQUARED","@stdlib/utils/pick":"pick","@stdlib/utils/pick-by":"pickBy","@stdlib/constants/math/float64-pinf":"PINF","@stdlib/namespace/pkg2alias":"pkg2alias","@stdlib/namespace/pkg2related":"pkg2related","@stdlib/os/platform":"PLATFORM","@stdlib/plot":"plot","@stdlib/plot/ctor":"Plot","@stdlib/utils/pluck":"pluck","@stdlib/utils/pop":"pop","@stdlib/utils/prepend":"prepend","@stdlib/utils/properties":"properties","@stdlib/utils/properties-in":"propertiesIn","@stdlib/utils/property-descriptor":"propertyDescriptor","@stdlib/utils/property-descriptor-in":"propertyDescriptorIn","@stdlib/utils/property-descriptors":"propertyDescriptors","@stdlib/utils/property-descriptors-in":"propertyDescriptorsIn","@stdlib/utils/property-names":"propertyNames","@stdlib/utils/property-names-in":"propertyNamesIn","@stdlib/utils/property-symbols":"propertySymbols","@stdlib/utils/property-symbols-in":"propertySymbolsIn","@stdlib/proxy/ctor":"Proxy","@stdlib/utils/push":"push","@stdlib/time/quarter-of-year":"quarterOfYear","@stdlib/random/iter/arcsine":"random.iterators.arcsine","@stdlib/random/iter/bernoulli":"random.iterators.bernoulli","@stdlib/random/iter/beta":"random.iterators.beta","@stdlib/random/iter/betaprime":"random.iterators.betaprime","@stdlib/random/iter/binomial":"random.iterators.binomial","@stdlib/random/iter/box-muller":"random.iterators.boxMuller","@stdlib/random/iter/cauchy":"random.iterators.cauchy","@stdlib/random/iter/chi":"random.iterators.chi","@stdlib/random/iter/chisquare":"random.iterators.chisquare","@stdlib/random/iter/cosine":"random.iterators.cosine","@stdlib/random/iter/discrete-uniform":"random.iterators.discreteUniform","@stdlib/random/iter/erlang":"random.iterators.erlang","@stdlib/random/iter/exponential":"random.iterators.exponential","@stdlib/random/iter/f":"random.iterators.f","@stdlib/random/iter/frechet":"random.iterators.frechet","@stdlib/random/iter/gamma":"random.iterators.gamma","@stdlib/random/iter/geometric":"random.iterators.geometric","@stdlib/random/iter/gumbel":"random.iterators.gumbel","@stdlib/random/iter/hypergeometric":"random.iterators.hypergeometric","@stdlib/random/iter/improved-ziggurat":"random.iterators.improvedZiggurat","@stdlib/random/iter/invgamma":"random.iterators.invgamma","@stdlib/random/iter/kumaraswamy":"random.iterators.kumaraswamy","@stdlib/random/iter/laplace":"random.iterators.laplace","@stdlib/random/iter/levy":"random.iterators.levy","@stdlib/random/iter/logistic":"random.iterators.logistic","@stdlib/random/iter/lognormal":"random.iterators.lognormal","@stdlib/random/iter/minstd":"random.iterators.minstd","@stdlib/random/iter/minstd-shuffle":"random.iterators.minstdShuffle","@stdlib/random/iter/mt19937":"random.iterators.mt19937","@stdlib/random/iter/negative-binomial":"random.iterators.negativeBinomial","@stdlib/random/iter/normal":"random.iterators.normal","@stdlib/random/iter/pareto-type1":"random.iterators.pareto1","@stdlib/random/iter/poisson":"random.iterators.poisson","@stdlib/random/iter/randi":"random.iterators.randi","@stdlib/random/iter/randn":"random.iterators.randn","@stdlib/random/iter/randu":"random.iterators.randu","@stdlib/random/iter/rayleigh":"random.iterators.rayleigh","@stdlib/random/iter/t":"random.iterators.t","@stdlib/random/iter/triangular":"random.iterators.triangular","@stdlib/random/iter/uniform":"random.iterators.uniform","@stdlib/random/iter/weibull":"random.iterators.weibull","@stdlib/random/streams/arcsine":"random.streams.arcsine","@stdlib/random/streams/bernoulli":"random.streams.bernoulli","@stdlib/random/streams/beta":"random.streams.beta","@stdlib/random/streams/betaprime":"random.streams.betaprime","@stdlib/random/streams/binomial":"random.streams.binomial","@stdlib/random/streams/box-muller":"random.streams.boxMuller","@stdlib/random/streams/cauchy":"random.streams.cauchy","@stdlib/random/streams/chi":"random.streams.chi","@stdlib/random/streams/chisquare":"random.streams.chisquare","@stdlib/random/streams/cosine":"random.streams.cosine","@stdlib/random/streams/discrete-uniform":"random.streams.discreteUniform","@stdlib/random/streams/erlang":"random.streams.erlang","@stdlib/random/streams/exponential":"random.streams.exponential","@stdlib/random/streams/f":"random.streams.f","@stdlib/random/streams/gamma":"random.streams.gamma","@stdlib/random/streams/geometric":"random.streams.geometric","@stdlib/random/streams/gumbel":"random.streams.gumbel","@stdlib/random/streams/improved-ziggurat":"random.streams.improvedZiggurat","@stdlib/random/streams/invgamma":"random.streams.invgamma","@stdlib/random/streams/kumaraswamy":"random.streams.kumaraswamy","@stdlib/random/streams/laplace":"random.streams.laplace","@stdlib/random/streams/levy":"random.streams.levy","@stdlib/random/streams/logistic":"random.streams.logistic","@stdlib/random/streams/lognormal":"random.streams.lognormal","@stdlib/random/streams/minstd":"random.streams.minstd","@stdlib/random/streams/minstd-shuffle":"random.streams.minstdShuffle","@stdlib/random/streams/mt19937":"random.streams.mt19937","@stdlib/random/streams/negative-binomial":"random.streams.negativeBinomial","@stdlib/random/streams/normal":"random.streams.normal","@stdlib/random/streams/pareto-type1":"random.streams.pareto1","@stdlib/random/streams/poisson":"random.streams.poisson","@stdlib/random/streams/randi":"random.streams.randi","@stdlib/random/streams/randn":"random.streams.randn","@stdlib/random/streams/randu":"random.streams.randu","@stdlib/random/streams/rayleigh":"random.streams.rayleigh","@stdlib/random/streams/t":"random.streams.t","@stdlib/random/streams/uniform":"random.streams.uniform","@stdlib/random/streams/weibull":"random.streams.weibull","@stdlib/stats/ranks":"ranks","@stdlib/regexp/basename":"RE_BASENAME","@stdlib/regexp/basename-posix":"RE_BASENAME_POSIX","@stdlib/regexp/basename-windows":"RE_BASENAME_WINDOWS","@stdlib/regexp/color-hexadecimal":"RE_COLOR_HEXADECIMAL","@stdlib/regexp/decimal-number":"RE_DECIMAL_NUMBER","@stdlib/regexp/dirname":"RE_DIRNAME","@stdlib/regexp/dirname-posix":"RE_DIRNAME_POSIX","@stdlib/regexp/dirname-windows":"RE_DIRNAME_WINDOWS","@stdlib/regexp/eol":"RE_EOL","@stdlib/regexp/extended-length-path":"RE_EXTENDED_LENGTH_PATH","@stdlib/regexp/extname":"RE_EXTNAME","@stdlib/regexp/extname-posix":"RE_EXTNAME_POSIX","@stdlib/regexp/extname-windows":"RE_EXTNAME_WINDOWS","@stdlib/regexp/filename":"RE_FILENAME","@stdlib/regexp/filename-posix":"RE_FILENAME_POSIX","@stdlib/regexp/filename-windows":"RE_FILENAME_WINDOWS","@stdlib/regexp/function-name":"RE_FUNCTION_NAME","@stdlib/regexp/native-function":"RE_NATIVE_FUNCTION","@stdlib/regexp/regexp":"RE_REGEXP","@stdlib/regexp/unc-path":"RE_UNC_PATH","@stdlib/regexp/utf16-surrogate-pair":"RE_UTF16_SURROGATE_PAIR","@stdlib/regexp/utf16-unpaired-surrogate":"RE_UTF16_UNPAIRED_SURROGATE","@stdlib/regexp/whitespace":"RE_WHITESPACE","@stdlib/fs/read-dir":"readDir","@stdlib/fs/read-file":"readFile","@stdlib/fs/read-file-list":"readFileList","@stdlib/fs/read-json":"readJSON","@stdlib/fs/read-wasm":"readWASM","@stdlib/complex/real":"real","@stdlib/utils/real-max":"realmax","@stdlib/utils/real-min":"realmin","@stdlib/utils/reduce":"reduce","@stdlib/utils/async/reduce":"reduceAsync","@stdlib/utils/reduce-right":"reduceRight","@stdlib/utils/async/reduce-right":"reduceRightAsync","@stdlib/utils/regexp-from-string":"reFromString","@stdlib/complex/reim":"reim","@stdlib/string/remove-first":"removeFirst","@stdlib/string/remove-last":"removeLast","@stdlib/string/remove-punctuation":"removePunctuation","@stdlib/string/remove-utf8-bom":"removeUTF8BOM","@stdlib/string/remove-words":"removeWords","@stdlib/fs/rename":"rename","@stdlib/utils/reorder-arguments":"reorderArguments","@stdlib/string/repeat":"repeat","@stdlib/string/replace":"replace","@stdlib/utils/escape-regexp-string":"rescape","@stdlib/fs/resolve-parent-path":"resolveParentPath","@stdlib/utils/reverse-arguments":"reverseArguments","@stdlib/string/reverse":"reverseString","@stdlib/random/base/reviver":"reviveBasePRNG","@stdlib/buffer/reviver":"reviveBuffer","@stdlib/complex/reviver":"reviveComplex","@stdlib/complex/reviver-float32":"reviveComplex64","@stdlib/complex/reviver-float64":"reviveComplex128","@stdlib/error/reviver":"reviveError","@stdlib/array/reviver":"reviveTypedArray","@stdlib/string/right-pad":"rpad","@stdlib/string/right-trim":"rtrim","@stdlib/utils/safe-int-max":"safeintmax","@stdlib/utils/safe-int-min":"safeintmin","@stdlib/random/sample":"sample","@stdlib/datasets/savoy-stopwords-fin":"SAVOY_STOPWORDS_FIN","@stdlib/datasets/savoy-stopwords-fr":"SAVOY_STOPWORDS_FR","@stdlib/datasets/savoy-stopwords-ger":"SAVOY_STOPWORDS_GER","@stdlib/datasets/savoy-stopwords-it":"SAVOY_STOPWORDS_IT","@stdlib/datasets/savoy-stopwords-por":"SAVOY_STOPWORDS_POR","@stdlib/datasets/savoy-stopwords-sp":"SAVOY_STOPWORDS_SP","@stdlib/datasets/savoy-stopwords-swe":"SAVOY_STOPWORDS_SWE","@stdlib/constants/time/seconds-in-day":"SECONDS_IN_DAY","@stdlib/constants/time/seconds-in-hour":"SECONDS_IN_HOUR","@stdlib/constants/time/seconds-in-minute":"SECONDS_IN_MINUTE","@stdlib/constants/time/seconds-in-week":"SECONDS_IN_WEEK","@stdlib/time/seconds-in-month":"secondsInMonth","@stdlib/time/seconds-in-year":"secondsInYear","@stdlib/utils/define-configurable-read-only-property":"setConfigurableReadOnly","@stdlib/utils/define-configurable-read-only-accessor":"setConfigurableReadOnlyAccessor","@stdlib/utils/define-configurable-read-write-accessor":"setConfigurableReadWriteAccessor","@stdlib/utils/define-configurable-write-only-accessor":"setConfigurableWriteOnlyAccessor","@stdlib/utils/define-memoized-read-only-property":"setMemoizedReadOnly","@stdlib/utils/define-nonenumerable-property":"setNonEnumerableProperty","@stdlib/utils/define-nonenumerable-read-only-property":"setNonEnumerableReadOnly","@stdlib/utils/define-nonenumerable-read-only-accessor":"setNonEnumerableReadOnlyAccessor","@stdlib/utils/define-nonenumerable-read-write-accessor":"setNonEnumerableReadWriteAccessor","@stdlib/utils/define-nonenumerable-write-only-accessor":"setNonEnumerableWriteOnlyAccessor","@stdlib/utils/define-read-only-property":"setReadOnly","@stdlib/utils/define-read-only-accessor":"setReadOnlyAccessor","@stdlib/utils/define-read-write-accessor":"setReadWriteAccessor","@stdlib/utils/define-write-only-accessor":"setWriteOnlyAccessor","@stdlib/array/shared-buffer":"SharedArrayBuffer","@stdlib/utils/shift":"shift","@stdlib/random/shuffle":"shuffle","@stdlib/utils/size-of":"sizeOf","@stdlib/utils/some":"some","@stdlib/utils/some-by":"someBy","@stdlib/utils/async/some-by":"someByAsync","@stdlib/utils/some-by-right":"someByRight","@stdlib/utils/async/some-by-right":"someByRightAsync","@stdlib/datasets/sotu":"SOTU","@stdlib/datasets/spache-revised":"SPACHE_REVISED","@stdlib/datasets/spam-assassin":"SPAM_ASSASSIN","@stdlib/plot/sparklines/base/ctor":"SparklineBase","@stdlib/array/to-sparse-iterator":"sparsearray2iterator","@stdlib/array/to-sparse-iterator-right":"sparsearray2iteratorRight","@stdlib/streams/node/split":"splitStream","@stdlib/constants/math/float64-sqrt-eps":"SQRT_EPS","@stdlib/constants/math/float64-sqrt-half":"SQRT_HALF","@stdlib/constants/math/float64-sqrt-half-pi":"SQRT_HALF_PI","@stdlib/constants/math/float64-sqrt-phi":"SQRT_PHI","@stdlib/constants/math/float64-sqrt-pi":"SQRT_PI","@stdlib/constants/math/float64-sqrt-three":"SQRT_THREE","@stdlib/constants/math/float64-sqrt-two":"SQRT_TWO","@stdlib/constants/math/float64-sqrt-two-pi":"SQRT_TWO_PI","@stdlib/utils/stack":"Stack","@stdlib/string/startcase":"startcase","@stdlib/string/starts-with":"startsWith","@stdlib/datasets/stopwords-en":"STOPWORDS_EN","@stdlib/array/to-strided-iterator":"stridedarray2iterator","@stdlib/streams/node/from-strided-array":"stridedArrayStream","@stdlib/buffer/from-string":"string2buffer","@stdlib/ndarray/sub2ind":"sub2ind","@stdlib/datasets/suthaharan-multi-hop-sensor-network":"SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK","@stdlib/datasets/suthaharan-single-hop-sensor-network":"SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK","@stdlib/symbol/ctor":"Symbol","@stdlib/utils/tabulate":"tabulate","@stdlib/utils/tabulate-by":"tabulateBy","@stdlib/utils/async/tabulate-by":"tabulateByAsync","@stdlib/time/tic":"tic","@stdlib/utils/timeit":"timeit","@stdlib/os/tmpdir":"tmpdir","@stdlib/time/toc":"toc","@stdlib/nlp/tokenize":"tokenize","@stdlib/streams/node/transform":"transformStream","@stdlib/string/trim":"trim","@stdlib/utils/try-catch":"trycatch","@stdlib/utils/async/try-catch":"trycatchAsync","@stdlib/utils/try-function":"tryFunction","@stdlib/utils/try-require":"tryRequire","@stdlib/utils/try-then":"trythen","@stdlib/utils/async/try-then":"trythenAsync","@stdlib/stats/ttest":"ttest","@stdlib/stats/ttest2":"ttest2","@stdlib/constants/math/float64-two-pi":"TWO_PI","@stdlib/array/typed":"typedarray","@stdlib/array/to-json":"typedarray2json","@stdlib/array/typed-complex-ctors":"typedarrayComplexCtors","@stdlib/array/typed-complex-dtypes":"typedarrayComplexDataTypes","@stdlib/array/typed-ctors":"typedarrayCtors","@stdlib/array/typed-dtypes":"typedarrayDataTypes","@stdlib/array/pool":"typedarraypool","@stdlib/utils/type-max":"typemax","@stdlib/utils/type-min":"typemin","@stdlib/utils/type-of":"typeOf","@stdlib/constants/math/uint8-max":"UINT8_MAX","@stdlib/constants/math/uint8-num-bytes":"UINT8_NUM_BYTES","@stdlib/array/uint8":"Uint8Array","@stdlib/array/uint8c":"Uint8ClampedArray","@stdlib/constants/math/uint16-max":"UINT16_MAX","@stdlib/constants/math/uint16-num-bytes":"UINT16_NUM_BYTES","@stdlib/array/uint16":"Uint16Array","@stdlib/constants/math/uint32-max":"UINT32_MAX","@stdlib/constants/math/uint32-num-bytes":"UINT32_NUM_BYTES","@stdlib/array/uint32":"Uint32Array","@stdlib/process/umask":"umask","@stdlib/string/uncapitalize":"uncapitalize","@stdlib/utils/uncapitalize-keys":"uncapitalizeKeys","@stdlib/utils/uncurry":"uncurry","@stdlib/utils/uncurry-right":"uncurryRight","@stdlib/constants/string/unicode-max":"UNICODE_MAX","@stdlib/constants/string/unicode-max-bmp":"UNICODE_MAX_BMP","@stdlib/plot/sparklines/unicode/column":"UnicodeColumnChartSparkline","@stdlib/plot/sparklines/unicode/line":"UnicodeLineChartSparkline","@stdlib/plot/sparklines/unicode":"UnicodeSparkline","@stdlib/plot/sparklines/unicode/tristate":"UnicodeTristateChartSparkline","@stdlib/plot/sparklines/unicode/up-down":"UnicodeUpDownChartSparkline","@stdlib/plot/sparklines/unicode/win-loss":"UnicodeWinLossChartSparkline","@stdlib/fs/unlink":"unlink","@stdlib/utils/unshift":"unshift","@stdlib/utils/until":"until","@stdlib/utils/async/until":"untilAsync","@stdlib/utils/until-each":"untilEach","@stdlib/utils/until-each-right":"untilEachRight","@stdlib/utils/unzip":"unzip","@stdlib/string/uppercase":"uppercase","@stdlib/utils/uppercase-keys":"uppercaseKeys","@stdlib/datasets/us-states-abbr":"US_STATES_ABBR","@stdlib/datasets/us-states-capitals":"US_STATES_CAPITALS","@stdlib/datasets/us-states-capitals-names":"US_STATES_CAPITALS_NAMES","@stdlib/datasets/us-states-names":"US_STATES_NAMES","@stdlib/datasets/us-states-names-capitals":"US_STATES_NAMES_CAPITALS","@stdlib/string/utf16-to-utf8-array":"utf16ToUTF8Array","@stdlib/stats/vartest":"vartest","@stdlib/utils/async/series-waterfall":"waterfall","@stdlib/utils/async/while":"whileAsync","@stdlib/utils/while-each":"whileEach","@stdlib/utils/while-each-right":"whileEachRight","@stdlib/utils/while":"whilst","@stdlib/utils/writable-properties":"writableProperties","@stdlib/utils/writable-properties-in":"writablePropertiesIn","@stdlib/utils/writable-property-names":"writablePropertyNames","@stdlib/utils/writable-property-names-in":"writablePropertyNamesIn","@stdlib/utils/writable-property-symbols":"writablePropertySymbols","@stdlib/utils/writable-property-symbols-in":"writablePropertySymbolsIn","@stdlib/fs/write-file":"writeFile","@stdlib/utils/zip":"zip","@stdlib/stats/ztest":"ztest","@stdlib/stats/ztest2":"ztest2"}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/datapackage.json b/lib/node_modules/@stdlib/namespace/pkg2alias/datapackage.json
new file mode 100644
index 000000000000..24d5eedb045a
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/datapackage.json
@@ -0,0 +1,56 @@
+{
+ "name": "stdlib-pkg2alias",
+ "version": "",
+ "title": "Standard Library Package Names and Aliases",
+ "description": "A mapping between standard library package names and aliases.",
+ "resources": [
+ {
+ "name": "stdlib-pkg2alias-json",
+ "title": "Standard Library Package Names and Aliases",
+ "description": "A mapping between standard library package names and aliases.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-pkg2alias-csv",
+ "title": "Standard Library Package Names and Aliases",
+ "description": "A mapping between standard library package names and aliases.",
+ "format": "csv",
+ "mediatype": "plain/csv",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.csv",
+ "schema": {
+ "fields": [
+ {
+ "name": "pkg",
+ "title": "Package Name",
+ "description": "Package name.",
+ "type": "string",
+ "format": "default"
+ },
+ {
+ "name": "alias",
+ "title": "Alias",
+ "description": "Alias.",
+ "type": "string",
+ "format": "default"
+ }
+ ]
+ }
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "stdlib",
+ "namespace",
+ "aliases",
+ "package",
+ "name",
+ "pkg"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/docs/repl.txt b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/repl.txt
new file mode 100644
index 000000000000..9cebfa491a1b
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/repl.txt
@@ -0,0 +1,21 @@
+
+{{alias}}( pkg )
+ Returns the alias associated with a specified package name.
+
+ Parameters
+ ----------
+ pkg: string
+ Package name.
+
+ Returns
+ -------
+ out: string|null
+ Alias.
+
+ Examples
+ --------
+ > var v = {{alias}}( '@stdlib/math/base/special/sin' )
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/index.d.ts b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/index.d.ts
new file mode 100644
index 000000000000..0a93f2924f3d
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/index.d.ts
@@ -0,0 +1,36 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns an alias associated with a specified package name.
+*
+* @param pkg - package name
+* @returns alias
+*
+* @example
+* var v = pkg2alias( '@stdlib/math/base/special/sin' );
+* // returns 'base.sin'
+*/
+declare function pkg2alias( pkg: string ): string | null;
+
+
+// EXPORTS //
+
+export = pkg2alias;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/test.ts b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/test.ts
new file mode 100644
index 000000000000..6f1c4c053049
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 pkg2alias = require( './index' );
+
+
+// TESTS //
+
+// The function returns a string or null...
+{
+ pkg2alias( '@stdlib/math/base/special/sin' ); // $ExpectType string | null
+}
+
+// The compiler throws an error if the function is not provided a string...
+{
+ pkg2alias( 5 ); // $ExpectError
+ pkg2alias( true ); // $ExpectError
+ pkg2alias( false ); // $ExpectError
+ pkg2alias( null ); // $ExpectError
+ pkg2alias( undefined ); // $ExpectError
+ pkg2alias( [] ); // $ExpectError
+ pkg2alias( {} ); // $ExpectError
+ pkg2alias( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ pkg2alias( '@stdlib/math/base/special/sin', 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/docs/usage.txt b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/usage.txt
new file mode 100644
index 000000000000..d3a79ecac163
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-pkg2alias [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/etc/cli_opts.json b/lib/node_modules/@stdlib/namespace/pkg2alias/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/examples/index.js b/lib/node_modules/@stdlib/namespace/pkg2alias/examples/index.js
new file mode 100644
index 000000000000..26a8119240c7
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/examples/index.js
@@ -0,0 +1,43 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var pkg2alias = require( './../lib' );
+
+var list;
+var len;
+var idx;
+var v1;
+var v2;
+var i;
+
+list = aliases();
+len = list.length;
+
+// Round-trip from alias-to-pkg-to-alias...
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v1 = alias2pkg( list[ idx ] );
+ v2 = pkg2alias( v1 );
+ console.log( 'alias: %s. pkg: %s.', list[ idx ], v1 );
+ console.log( 'pkg: %s. alias: %s.', v1, v2 );
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/lib/index.js b/lib/node_modules/@stdlib/namespace/pkg2alias/lib/index.js
new file mode 100644
index 000000000000..71ddd24f2427
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/lib/index.js
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 the alias associated with a specified package name.
+*
+* @module @stdlib/namespace/pkg2alias
+*
+* @example
+* var pkg2alias = require( '@stdlib/namespace/pkg2alias' );
+*
+* var v = pkg2alias( '@stdlib/math/base/special/sin' );
+* // returns 'base.sin'
+*/
+
+// MODULES //
+
+var pkg2alias = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = pkg2alias;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/lib/main.js b/lib/node_modules/@stdlib/namespace/pkg2alias/lib/main.js
new file mode 100644
index 000000000000..fd8ea0b9cb09
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/lib/main.js
@@ -0,0 +1,54 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var PKG_TO_ALIAS = require( './../data/data.json' );
+
+
+// MAIN //
+
+/**
+* Returns the alias associated with a specified package name.
+*
+* @param {string} pkg - package name
+* @throws {TypeError} must provide a string
+* @returns {(string|null)} alias
+*
+* @example
+* var v = pkg2alias( '@stdlib/math/base/special/sin' );
+* // returns 'base.sin'
+*/
+function pkg2alias( pkg ) {
+ if ( !isString( pkg ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + pkg + '`.' );
+ }
+ if ( hasOwnProp( PKG_TO_ALIAS, pkg ) ) {
+ return PKG_TO_ALIAS[ pkg ];
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = pkg2alias;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/package.json b/lib/node_modules/@stdlib/namespace/pkg2alias/package.json
new file mode 100644
index 000000000000..ed6dc3a5ef23
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/package.json
@@ -0,0 +1,68 @@
+{
+ "name": "@stdlib/namespace/pkg2alias",
+ "version": "0.0.0",
+ "description": "Return the alias associated with a specified package name.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-pkg2alias": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "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",
+ "standard",
+ "library",
+ "lib",
+ "aliases",
+ "alias",
+ "namespace",
+ "package",
+ "name",
+ "pkg"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/scripts/build.js b/lib/node_modules/@stdlib/namespace/pkg2alias/scripts/build.js
new file mode 100644
index 000000000000..085da28c8de8
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/scripts/build.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var namespace = require( '@stdlib/namespace' );
+var objectKeys = require( '@stdlib/utils/keys' );
+
+
+// VARIABLES //
+
+var debug = logger( 'namespace:pkg2alias:build' );
+
+// Output file paths:
+var OUTPUT_JSON = resolve( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_CSV = resolve( __dirname, '..', 'data', 'data.csv' );
+
+
+// FUNCTIONS //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var fopts;
+ var keys;
+ var json;
+ var csv;
+ var ns;
+ var i;
+
+ debug( 'Extracting namespace package names and aliases...' );
+ ns = namespace();
+ json = {};
+ for ( i = 0; i < ns.length; i++ ) {
+ json[ ns[i].path ] = ns[ i ].alias;
+ }
+
+ debug( 'Writing to JSON file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_JSON, JSON.stringify( json ), fopts );
+
+ debug( 'Writing to CSV file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ keys = objectKeys( json );
+ csv = '';
+ for ( i = 0; i < keys.length; i++ ) {
+ csv += '"' + keys[ i ] + '",' + json[ keys[i] ] + '\n'; // Note: ensures trailing newline
+ }
+ writeFile( OUTPUT_CSV, csv, fopts );
+}
+
+
+// MAIN //
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.cli.js b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.cli.js
new file mode 100644
index 000000000000..8a62431e4ff4
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.cli.js
@@ -0,0 +1,181 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints an alias', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '@stdlib/math/base/special/sin'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), 'base.sin\n', 'prints expected value' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
+
+tape( 'if unable to resolve an alias, the command-line interface sets a non-zero exit code', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'fjaldfjadljfeoejreandfljasdfjadsfjs'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.pass( error.message );
+ t.strictEqual( error.code, 1, 'expected exit code' );
+ }
+ t.strictEqual( stdout.toString(), '', 'does not print to` stdout`' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js
new file mode 100644
index 000000000000..8ff0585efe33
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2alias/test/test.js
@@ -0,0 +1,96 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var DATA = require( './../data/data.json' );
+var pkg2alias = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof pkg2alias, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a string', function test( t ) {
+ var values;
+ 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() {
+ pkg2alias( value );
+ };
+ }
+});
+
+tape( 'the function returns an alias', function test( t ) {
+ var expected;
+ var actual;
+ var list;
+ var pkg;
+ var i;
+
+ list = aliases();
+ for ( i = 0; i < list.length; i++ ) {
+ pkg = alias2pkg( list[i] );
+ expected = DATA[ pkg ];
+ actual = pkg2alias( pkg );
+ t.strictEqual( typeof actual, 'string', 'returns a string' );
+ t.strictEqual( actual, expected, 'returns expected value for '+pkg );
+ }
+ t.end();
+});
+
+tape( 'the function returns `null` if provided an unrecognized package name', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ 'adfkaljdfdsafs',
+ 'adklfadjflajdslfjalsdf',
+ 'adflkajdlkfjasdlkfjsadlkfjlasdjflsdjfla'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.strictEqual( pkg2alias( values[ i ] ), null, 'returns expected value' );
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/LICENSE b/lib/node_modules/@stdlib/namespace/pkg2related/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/README.md b/lib/node_modules/@stdlib/namespace/pkg2related/README.md
new file mode 100644
index 000000000000..78e1e00015d9
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/README.md
@@ -0,0 +1,190 @@
+
+
+# pkg2related
+
+> Return package names related to a specified package name.
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var pkg2related = require( '@stdlib/namespace/pkg2related' );
+```
+
+#### pkg2related( pkg )
+
+Returns package names related to a specified package name.
+
+```javascript
+var out = pkg2related( '@stdlib/math/base/special/sin' );
+// returns [...]
+```
+
+If provided an unrecognized package name, the function returns `null`.
+
+```javascript
+var out = pkg2related( 'unrecognized_pkg_beep_boop_bop_bip' );
+// returns null
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var pkg2related = require( '@stdlib/namespace/pkg2related' );
+
+var list;
+var len;
+var idx;
+var pkg;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ pkg = alias2pkg( v );
+ console.log( 'alias: %s. related: %s.', v, pkg2related( pkg ).join( ', ' ) );
+}
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-pkg2related [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-pkg2related '@stdlib/math/base/special/sin'
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
+
+
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/benchmark/benchmark.js b/lib/node_modules/@stdlib/namespace/pkg2related/benchmark/benchmark.js
new file mode 100644
index 000000000000..804e7f7e59ec
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/benchmark/benchmark.js
@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isStringArray = require( '@stdlib/assert/is-string-array' ).primitives;
+var pkg = require( './../package.json' ).name;
+var pkg2related = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var values;
+ var v;
+ var i;
+
+ values = [
+ '@stdlib/math/base/special/abs',
+ '@stdlib/math/base/special/cos',
+ '@stdlib/math/base/special/sin'
+ ];
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = pkg2related( values[ i%values.length ] );
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( v.length > 0 && !isStringArray( v ) ) {
+ b.fail( 'should return an array of strings' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/bin/cli b/lib/node_modules/@stdlib/namespace/pkg2related/bin/cli
new file mode 100755
index 000000000000..2c915ed50ca3
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/bin/cli
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var pkg2related = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Resolve related package names...
+ out = pkg2related( args[ 0 ] );
+ if ( out ) {
+ if ( out.length ) {
+ console.log( out.join( '\n' ) ); // eslint-disable-line no-console
+ }
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv
new file mode 100644
index 000000000000..9336632791aa
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.csv
@@ -0,0 +1,1894 @@
+"@stdlib/datasets/afinn-96","@stdlib/datasets/afinn-111"
+"@stdlib/datasets/afinn-111","@stdlib/datasets/afinn-96"
+"@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related,@stdlib/namespace/aliases,@stdlib/namespace/pkg2alias"
+"@stdlib/namespace/alias2related","@stdlib/namespace/alias2pkg,@stdlib/namespace/aliases,@stdlib/namespace/pkg2related"
+"@stdlib/namespace/aliases","@stdlib/namespace/alias2pkg,@stdlib/namespace/alias2related,@stdlib/namespace/pkg2alias"
+"@stdlib/buffer/alloc-unsafe","@stdlib/buffer/ctor,@stdlib/buffer/from-array,@stdlib/buffer/from-arraybuffer,@stdlib/buffer/from-buffer,@stdlib/buffer/from-string"
+"@stdlib/stats/anova1",""
+"@stdlib/datasets/anscombes-quartet",""
+"@stdlib/utils/any","@stdlib/utils/any-by,@stdlib/utils/every,@stdlib/utils/for-each,@stdlib/utils/none,@stdlib/utils/some"
+"@stdlib/utils/any-by","@stdlib/utils/async/any-by,@stdlib/utils/any-by-right,@stdlib/utils/every-by,@stdlib/utils/for-each,@stdlib/utils/none-by,@stdlib/utils/some-by"
+"@stdlib/utils/async/any-by","@stdlib/utils/any-by,@stdlib/utils/async/any-by-right,@stdlib/utils/async/every-by,@stdlib/utils/async/for-each,@stdlib/utils/async/none-by,@stdlib/utils/async/some-by"
+"@stdlib/utils/any-by-right","@stdlib/utils/any-by,@stdlib/utils/async/any-by-right,@stdlib/utils/every-by-right,@stdlib/utils/for-each-right,@stdlib/utils/none-by-right,@stdlib/utils/some-by-right"
+"@stdlib/utils/async/any-by-right","@stdlib/utils/async/any-by,@stdlib/utils/any-by-right,@stdlib/utils/async/every-by-right,@stdlib/utils/async/for-each-right,@stdlib/utils/async/none-by-right,@stdlib/utils/async/some-by-right"
+"@stdlib/constants/math/float64-apery",""
+"@stdlib/utils/append","@stdlib/utils/prepend,@stdlib/utils/push"
+"@stdlib/os/arch","@stdlib/os/platform"
+"@stdlib/utils/argument-function","@stdlib/utils/constant-function,@stdlib/utils/identity-function"
+"@stdlib/process/argv","@stdlib/process/env"
+"@stdlib/ndarray/array","@stdlib/ndarray/ctor"
+"@stdlib/buffer/from-array","@stdlib/buffer/ctor,@stdlib/buffer/from-arraybuffer,@stdlib/buffer/from-buffer,@stdlib/buffer/from-string"
+"@stdlib/array/to-iterator","@stdlib/array/from-iterator,@stdlib/array/to-circular-iterator,@stdlib/array/to-iterator-right,@stdlib/array/to-strided-iterator"
+"@stdlib/array/to-iterator-right","@stdlib/array/from-iterator,@stdlib/array/to-iterator"
+"@stdlib/array/buffer","@stdlib/buffer/ctor,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/shared-buffer,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/buffer/from-arraybuffer","@stdlib/buffer/ctor,@stdlib/buffer/from-array,@stdlib/buffer/from-buffer,@stdlib/buffer/from-string"
+"@stdlib/array/ctors","@stdlib/array/typed-ctors"
+"@stdlib/array/dtype","@stdlib/array/dtypes"
+"@stdlib/array/dtypes","@stdlib/array/typed-dtypes,@stdlib/ndarray/dtypes"
+"@stdlib/array/min-dtype","@stdlib/array/dtypes,@stdlib/array/promotion-rules,@stdlib/array/safe-casts"
+"@stdlib/array/next-dtype","@stdlib/array/dtype,@stdlib/array/dtypes"
+"@stdlib/array/promotion-rules","@stdlib/array/dtypes,@stdlib/array/safe-casts,@stdlib/ndarray/promotion-rules"
+"@stdlib/array/safe-casts","@stdlib/array/convert,@stdlib/array/convert-same,@stdlib/array/dtypes,@stdlib/array/same-kind-casts,@stdlib/ndarray/safe-casts"
+"@stdlib/array/same-kind-casts","@stdlib/array/convert,@stdlib/array/convert-same,@stdlib/array/dtypes,@stdlib/array/safe-casts,@stdlib/ndarray/same-kind-casts"
+"@stdlib/array/shape","@stdlib/ndarray/ctor"
+"@stdlib/streams/node/from-array","@stdlib/streams/node/from-circular-array,@stdlib/streams/node/from-iterator,@stdlib/streams/node/from-strided-array"
+"@stdlib/array/to-view-iterator","@stdlib/array/from-iterator,@stdlib/array/to-iterator,@stdlib/array/to-strided-iterator,@stdlib/array/to-view-iterator-right"
+"@stdlib/array/to-view-iterator-right","@stdlib/array/from-iterator,@stdlib/array/to-iterator-right,@stdlib/array/to-strided-iterator,@stdlib/array/to-view-iterator"
+"@stdlib/symbol/async-iterator","@stdlib/symbol/ctor,@stdlib/symbol/iterator"
+"@stdlib/stats/bartlett-test","@stdlib/stats/vartest"
+"@stdlib/math/base/special/abs","@stdlib/math/base/special/abs2"
+"@stdlib/math/base/special/abs2","@stdlib/math/base/special/abs"
+"@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/relative-difference,@stdlib/math/base/utils/float64-epsilon-difference"
+"@stdlib/math/base/special/int32-abs","@stdlib/math/base/special/abs"
+"@stdlib/math/base/special/acos","@stdlib/math/base/special/acosh,@stdlib/math/base/special/asin,@stdlib/math/base/special/atan"
+"@stdlib/math/base/special/acosh","@stdlib/math/base/special/acos,@stdlib/math/base/special/asinh,@stdlib/math/base/special/atanh"
+"@stdlib/math/base/special/acoth","@stdlib/math/base/special/acosh,@stdlib/math/base/special/asinh,@stdlib/math/base/special/atanh"
+"@stdlib/math/base/special/acovercos","@stdlib/math/base/special/acoversin,@stdlib/math/base/special/avercos,@stdlib/math/base/special/covercos,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/acoversin","@stdlib/math/base/special/acovercos,@stdlib/math/base/special/aversin,@stdlib/math/base/special/coversin,@stdlib/math/base/special/versin"
+"@stdlib/math/base/special/ahavercos","@stdlib/math/base/special/ahaversin,@stdlib/math/base/special/havercos,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/ahaversin","@stdlib/math/base/special/ahavercos,@stdlib/math/base/special/haversin,@stdlib/math/base/special/versin"
+"@stdlib/math/base/special/asin","@stdlib/math/base/special/acos,@stdlib/math/base/special/asinh,@stdlib/math/base/special/atan"
+"@stdlib/math/base/special/asinh","@stdlib/math/base/special/acosh,@stdlib/math/base/special/asin,@stdlib/math/base/special/atanh"
+"@stdlib/math/base/special/atan","@stdlib/math/base/special/acos,@stdlib/math/base/special/asin,@stdlib/math/base/special/atanh"
+"@stdlib/math/base/special/atan2","@stdlib/math/base/special/atan"
+"@stdlib/math/base/special/atanh","@stdlib/math/base/special/acosh,@stdlib/math/base/special/asinh,@stdlib/math/base/special/atan"
+"@stdlib/math/base/special/avercos","@stdlib/math/base/special/aversin,@stdlib/math/base/special/versin"
+"@stdlib/math/base/special/aversin","@stdlib/math/base/special/avercos,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/bernoulli",""
+"@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1,@stdlib/math/base/special/bessely0,@stdlib/math/base/special/bessely1"
+"@stdlib/math/base/special/besselj1","@stdlib/math/base/special/besselj0,@stdlib/math/base/special/bessely0,@stdlib/math/base/special/bessely1"
+"@stdlib/math/base/special/bessely0","@stdlib/math/base/special/besselj0,@stdlib/math/base/special/besselj1,@stdlib/math/base/special/bessely1"
+"@stdlib/math/base/special/bessely1","@stdlib/math/base/special/besselj0,@stdlib/math/base/special/besselj1,@stdlib/math/base/special/bessely0"
+"@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc,@stdlib/math/base/special/betaincinv,@stdlib/math/base/special/betaln"
+"@stdlib/math/base/special/betainc","@stdlib/math/base/special/beta,@stdlib/math/base/special/betaincinv,@stdlib/math/base/special/betaln"
+"@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/beta,@stdlib/math/base/special/betainc,@stdlib/math/base/special/betaln"
+"@stdlib/math/base/special/betaln","@stdlib/math/base/special/beta,@stdlib/math/base/special/betainc,@stdlib/math/base/special/betaincinv"
+"@stdlib/math/base/special/binet","@stdlib/math/base/special/fibonacci,@stdlib/math/base/special/negafibonacci"
+"@stdlib/math/base/special/binomcoef",""
+"@stdlib/math/base/special/binomcoefln",""
+"@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcoxinv,@stdlib/math/base/special/boxcox1p,@stdlib/math/base/special/boxcox1pinv"
+"@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox,@stdlib/math/base/special/boxcox1pinv,@stdlib/math/base/special/boxcoxinv"
+"@stdlib/math/base/special/boxcox1pinv","@stdlib/math/base/special/boxcox,@stdlib/math/base/special/boxcox1p,@stdlib/math/base/special/boxcoxinv"
+"@stdlib/math/base/special/boxcoxinv","@stdlib/math/base/special/boxcox,@stdlib/math/base/special/boxcox1p,@stdlib/math/base/special/boxcox1pinv"
+"@stdlib/math/base/complex/abs","@stdlib/math/base/complex/abs2,@stdlib/math/base/special/abs"
+"@stdlib/math/base/complex/abs2","@stdlib/math/base/complex/abs,@stdlib/math/base/special/abs2"
+"@stdlib/math/base/complex/add","@stdlib/math/base/complex/divide,@stdlib/math/base/complex/multiply,@stdlib/math/base/complex/subtract"
+"@stdlib/math/base/special/cbrt","@stdlib/math/base/special/pow,@stdlib/math/base/special/sqrt"
+"@stdlib/math/base/complex/ceil","@stdlib/math/base/complex/ceiln,@stdlib/math/base/complex/floor,@stdlib/math/base/complex/round"
+"@stdlib/math/base/complex/ceiln","@stdlib/math/base/complex/ceil,@stdlib/math/base/complex/floorn,@stdlib/math/base/complex/roundn"
+"@stdlib/math/base/complex/cis",""
+"@stdlib/math/base/complex/divide","@stdlib/math/base/complex/add,@stdlib/math/base/complex/multiply,@stdlib/math/base/complex/subtract"
+"@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floor,@stdlib/math/base/special/round"
+"@stdlib/math/base/special/ceil2","@stdlib/math/base/special/ceil,@stdlib/math/base/special/ceil10,@stdlib/math/base/special/floor2,@stdlib/math/base/special/round2"
+"@stdlib/math/base/special/ceil10","@stdlib/math/base/special/ceil,@stdlib/math/base/special/ceil2,@stdlib/math/base/special/floor10,@stdlib/math/base/special/round10"
+"@stdlib/math/base/special/ceilb","@stdlib/math/base/special/ceil,@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floorb,@stdlib/math/base/special/roundb"
+"@stdlib/math/base/special/ceiln","@stdlib/math/base/special/ceil,@stdlib/math/base/special/ceilb,@stdlib/math/base/special/floorn,@stdlib/math/base/special/roundn"
+"@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/ceil,@stdlib/math/base/special/floorsd,@stdlib/math/base/special/roundsd,@stdlib/math/base/special/truncsd"
+"@stdlib/math/base/complex/exp",""
+"@stdlib/math/base/complex/flipsign","@stdlib/math/base/complex/negate,@stdlib/math/base/complex/signum"
+"@stdlib/math/base/complex/floor","@stdlib/math/base/complex/ceil,@stdlib/math/base/complex/floorn,@stdlib/math/base/complex/round"
+"@stdlib/math/base/complex/floorn","@stdlib/math/base/complex/ceiln,@stdlib/math/base/complex/floor,@stdlib/math/base/complex/roundn"
+"@stdlib/math/base/complex/inv","@stdlib/math/base/complex/divide"
+"@stdlib/math/base/special/clamp","@stdlib/math/base/special/wrap"
+"@stdlib/math/base/complex/multiply","@stdlib/math/base/complex/add,@stdlib/math/base/complex/divide,@stdlib/math/base/complex/subtract"
+"@stdlib/math/base/complex/negate","@stdlib/math/base/complex/abs"
+"@stdlib/math/base/tools/continued-fraction",""
+"@stdlib/math/base/special/copysign","@stdlib/math/base/special/flipsign"
+"@stdlib/math/base/special/cos","@stdlib/math/base/special/cospi,@stdlib/math/base/special/cosm1,@stdlib/math/base/special/sin,@stdlib/math/base/special/tan"
+"@stdlib/math/base/special/cosh","@stdlib/math/base/special/cos,@stdlib/math/base/special/sinh,@stdlib/math/base/special/tanh"
+"@stdlib/math/base/special/cosm1","@stdlib/math/base/special/cos"
+"@stdlib/math/base/special/cospi","@stdlib/math/base/special/cos"
+"@stdlib/math/base/special/covercos","@stdlib/math/base/special/coversin,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/coversin","@stdlib/math/base/special/covercos,@stdlib/math/base/special/versin"
+"@stdlib/math/base/complex/phase","@stdlib/math/base/complex/abs"
+"@stdlib/math/base/complex/polar","@stdlib/math/base/complex/abs,@stdlib/math/base/complex/phase"
+"@stdlib/math/base/complex/round","@stdlib/math/base/complex/ceil,@stdlib/math/base/complex/floor,@stdlib/math/base/complex/roundn"
+"@stdlib/math/base/complex/roundn","@stdlib/math/base/complex/ceiln,@stdlib/math/base/complex/floorn,@stdlib/math/base/complex/round"
+"@stdlib/math/base/complex/signum","@stdlib/math/base/special/signum"
+"@stdlib/math/base/complex/subtract","@stdlib/math/base/complex/add,@stdlib/math/base/complex/divide,@stdlib/math/base/complex/multiply"
+"@stdlib/blas/base/dasum","@stdlib/blas/base/daxpy,@stdlib/blas/base/dcopy"
+"@stdlib/blas/base/daxpy","@stdlib/blas/base/dasum,@stdlib/blas/base/dcopy"
+"@stdlib/blas/base/dcopy","@stdlib/blas/base/dasum,@stdlib/blas/base/daxpy"
+"@stdlib/math/base/special/deg2rad","@stdlib/math/base/special/rad2deg"
+"@stdlib/math/base/special/digamma","@stdlib/math/base/special/trigamma,@stdlib/math/base/special/gamma"
+"@stdlib/math/base/special/dirac-delta","@stdlib/math/base/special/kronecker-delta"
+"@stdlib/stats/base/dists/arcsine/ctor",""
+"@stdlib/stats/base/dists/arcsine/cdf",""
+"@stdlib/stats/base/dists/arcsine/entropy",""
+"@stdlib/stats/base/dists/arcsine/kurtosis",""
+"@stdlib/stats/base/dists/arcsine/logcdf",""
+"@stdlib/stats/base/dists/arcsine/logpdf",""
+"@stdlib/stats/base/dists/arcsine/mean",""
+"@stdlib/stats/base/dists/arcsine/median",""
+"@stdlib/stats/base/dists/arcsine/mode",""
+"@stdlib/stats/base/dists/arcsine/pdf",""
+"@stdlib/stats/base/dists/arcsine/quantile",""
+"@stdlib/stats/base/dists/arcsine/skewness",""
+"@stdlib/stats/base/dists/arcsine/stdev",""
+"@stdlib/stats/base/dists/arcsine/variance",""
+"@stdlib/stats/base/dists/bernoulli/ctor",""
+"@stdlib/stats/base/dists/bernoulli/cdf",""
+"@stdlib/stats/base/dists/bernoulli/entropy",""
+"@stdlib/stats/base/dists/bernoulli/kurtosis",""
+"@stdlib/stats/base/dists/bernoulli/mean",""
+"@stdlib/stats/base/dists/bernoulli/median",""
+"@stdlib/stats/base/dists/bernoulli/mgf",""
+"@stdlib/stats/base/dists/bernoulli/mode",""
+"@stdlib/stats/base/dists/bernoulli/pmf",""
+"@stdlib/stats/base/dists/bernoulli/quantile",""
+"@stdlib/stats/base/dists/bernoulli/skewness",""
+"@stdlib/stats/base/dists/bernoulli/stdev",""
+"@stdlib/stats/base/dists/bernoulli/variance",""
+"@stdlib/stats/base/dists/beta/ctor",""
+"@stdlib/stats/base/dists/beta/cdf",""
+"@stdlib/stats/base/dists/beta/entropy",""
+"@stdlib/stats/base/dists/beta/kurtosis",""
+"@stdlib/stats/base/dists/beta/logcdf",""
+"@stdlib/stats/base/dists/beta/logpdf",""
+"@stdlib/stats/base/dists/beta/mean",""
+"@stdlib/stats/base/dists/beta/median",""
+"@stdlib/stats/base/dists/beta/mgf",""
+"@stdlib/stats/base/dists/beta/mode",""
+"@stdlib/stats/base/dists/beta/pdf",""
+"@stdlib/stats/base/dists/beta/quantile",""
+"@stdlib/stats/base/dists/beta/skewness",""
+"@stdlib/stats/base/dists/beta/stdev",""
+"@stdlib/stats/base/dists/beta/variance",""
+"@stdlib/stats/base/dists/betaprime/ctor",""
+"@stdlib/stats/base/dists/betaprime/cdf",""
+"@stdlib/stats/base/dists/betaprime/kurtosis",""
+"@stdlib/stats/base/dists/betaprime/logcdf",""
+"@stdlib/stats/base/dists/betaprime/logpdf",""
+"@stdlib/stats/base/dists/betaprime/mean",""
+"@stdlib/stats/base/dists/betaprime/mode",""
+"@stdlib/stats/base/dists/betaprime/pdf",""
+"@stdlib/stats/base/dists/betaprime/quantile",""
+"@stdlib/stats/base/dists/betaprime/skewness",""
+"@stdlib/stats/base/dists/betaprime/stdev",""
+"@stdlib/stats/base/dists/betaprime/variance",""
+"@stdlib/stats/base/dists/binomial/ctor",""
+"@stdlib/stats/base/dists/binomial/cdf",""
+"@stdlib/stats/base/dists/binomial/entropy",""
+"@stdlib/stats/base/dists/binomial/kurtosis",""
+"@stdlib/stats/base/dists/binomial/logpmf",""
+"@stdlib/stats/base/dists/binomial/mean",""
+"@stdlib/stats/base/dists/binomial/median",""
+"@stdlib/stats/base/dists/binomial/mgf",""
+"@stdlib/stats/base/dists/binomial/mode",""
+"@stdlib/stats/base/dists/binomial/pmf",""
+"@stdlib/stats/base/dists/binomial/quantile",""
+"@stdlib/stats/base/dists/binomial/skewness",""
+"@stdlib/stats/base/dists/binomial/stdev",""
+"@stdlib/stats/base/dists/binomial/variance",""
+"@stdlib/stats/base/dists/cauchy/ctor",""
+"@stdlib/stats/base/dists/cauchy/cdf",""
+"@stdlib/stats/base/dists/cauchy/entropy",""
+"@stdlib/stats/base/dists/cauchy/logcdf",""
+"@stdlib/stats/base/dists/cauchy/logpdf",""
+"@stdlib/stats/base/dists/cauchy/median",""
+"@stdlib/stats/base/dists/cauchy/mode",""
+"@stdlib/stats/base/dists/cauchy/pdf",""
+"@stdlib/stats/base/dists/cauchy/quantile",""
+"@stdlib/stats/base/dists/chi/cdf",""
+"@stdlib/stats/base/dists/chi/ctor",""
+"@stdlib/stats/base/dists/chi/entropy",""
+"@stdlib/stats/base/dists/chi/kurtosis",""
+"@stdlib/stats/base/dists/chi/logpdf",""
+"@stdlib/stats/base/dists/chi/mean",""
+"@stdlib/stats/base/dists/chi/mode",""
+"@stdlib/stats/base/dists/chi/pdf",""
+"@stdlib/stats/base/dists/chi/quantile",""
+"@stdlib/stats/base/dists/chi/skewness",""
+"@stdlib/stats/base/dists/chi/stdev",""
+"@stdlib/stats/base/dists/chi/variance",""
+"@stdlib/stats/base/dists/chisquare/cdf",""
+"@stdlib/stats/base/dists/chisquare/ctor",""
+"@stdlib/stats/base/dists/chisquare/entropy",""
+"@stdlib/stats/base/dists/chisquare/kurtosis",""
+"@stdlib/stats/base/dists/chisquare/logpdf",""
+"@stdlib/stats/base/dists/chisquare/mean",""
+"@stdlib/stats/base/dists/chisquare/mgf",""
+"@stdlib/stats/base/dists/chisquare/mode",""
+"@stdlib/stats/base/dists/chisquare/pdf",""
+"@stdlib/stats/base/dists/chisquare/quantile",""
+"@stdlib/stats/base/dists/chisquare/skewness",""
+"@stdlib/stats/base/dists/chisquare/stdev",""
+"@stdlib/stats/base/dists/chisquare/variance",""
+"@stdlib/stats/base/dists/cosine/cdf",""
+"@stdlib/stats/base/dists/cosine/ctor",""
+"@stdlib/stats/base/dists/cosine/kurtosis",""
+"@stdlib/stats/base/dists/cosine/logcdf",""
+"@stdlib/stats/base/dists/cosine/logpdf",""
+"@stdlib/stats/base/dists/cosine/mean",""
+"@stdlib/stats/base/dists/cosine/median",""
+"@stdlib/stats/base/dists/cosine/mgf",""
+"@stdlib/stats/base/dists/cosine/mode",""
+"@stdlib/stats/base/dists/cosine/pdf",""
+"@stdlib/stats/base/dists/cosine/quantile",""
+"@stdlib/stats/base/dists/cosine/skewness",""
+"@stdlib/stats/base/dists/cosine/stdev",""
+"@stdlib/stats/base/dists/cosine/variance",""
+"@stdlib/stats/base/dists/degenerate/cdf",""
+"@stdlib/stats/base/dists/degenerate/ctor",""
+"@stdlib/stats/base/dists/degenerate/entropy",""
+"@stdlib/stats/base/dists/degenerate/logcdf",""
+"@stdlib/stats/base/dists/degenerate/logpdf",""
+"@stdlib/stats/base/dists/degenerate/logpmf",""
+"@stdlib/stats/base/dists/degenerate/mean",""
+"@stdlib/stats/base/dists/degenerate/median",""
+"@stdlib/stats/base/dists/degenerate/mgf",""
+"@stdlib/stats/base/dists/degenerate/mode",""
+"@stdlib/stats/base/dists/degenerate/pdf",""
+"@stdlib/stats/base/dists/degenerate/pmf",""
+"@stdlib/stats/base/dists/degenerate/quantile",""
+"@stdlib/stats/base/dists/degenerate/stdev",""
+"@stdlib/stats/base/dists/degenerate/variance",""
+"@stdlib/stats/base/dists/discrete-uniform/cdf",""
+"@stdlib/stats/base/dists/discrete-uniform/ctor",""
+"@stdlib/stats/base/dists/discrete-uniform/kurtosis",""
+"@stdlib/stats/base/dists/discrete-uniform/logcdf",""
+"@stdlib/stats/base/dists/discrete-uniform/logpmf",""
+"@stdlib/stats/base/dists/discrete-uniform/mean",""
+"@stdlib/stats/base/dists/discrete-uniform/median",""
+"@stdlib/stats/base/dists/discrete-uniform/mgf",""
+"@stdlib/stats/base/dists/discrete-uniform/pmf",""
+"@stdlib/stats/base/dists/discrete-uniform/quantile",""
+"@stdlib/stats/base/dists/discrete-uniform/skewness",""
+"@stdlib/stats/base/dists/discrete-uniform/stdev",""
+"@stdlib/stats/base/dists/discrete-uniform/variance",""
+"@stdlib/stats/base/dists/erlang/cdf",""
+"@stdlib/stats/base/dists/erlang/entropy",""
+"@stdlib/stats/base/dists/erlang/ctor",""
+"@stdlib/stats/base/dists/erlang/kurtosis",""
+"@stdlib/stats/base/dists/erlang/logpdf",""
+"@stdlib/stats/base/dists/erlang/mean",""
+"@stdlib/stats/base/dists/erlang/mgf",""
+"@stdlib/stats/base/dists/erlang/mode",""
+"@stdlib/stats/base/dists/erlang/pdf",""
+"@stdlib/stats/base/dists/erlang/quantile",""
+"@stdlib/stats/base/dists/erlang/skewness",""
+"@stdlib/stats/base/dists/erlang/stdev",""
+"@stdlib/stats/base/dists/erlang/variance",""
+"@stdlib/stats/base/dists/exponential/cdf",""
+"@stdlib/stats/base/dists/exponential/entropy",""
+"@stdlib/stats/base/dists/exponential/ctor",""
+"@stdlib/stats/base/dists/exponential/kurtosis",""
+"@stdlib/stats/base/dists/exponential/logcdf",""
+"@stdlib/stats/base/dists/exponential/logpdf",""
+"@stdlib/stats/base/dists/exponential/mean",""
+"@stdlib/stats/base/dists/exponential/median",""
+"@stdlib/stats/base/dists/exponential/mgf",""
+"@stdlib/stats/base/dists/exponential/mode",""
+"@stdlib/stats/base/dists/exponential/pdf",""
+"@stdlib/stats/base/dists/exponential/quantile",""
+"@stdlib/stats/base/dists/exponential/skewness",""
+"@stdlib/stats/base/dists/exponential/stdev",""
+"@stdlib/stats/base/dists/exponential/variance",""
+"@stdlib/stats/base/dists/f/cdf",""
+"@stdlib/stats/base/dists/f/entropy",""
+"@stdlib/stats/base/dists/f/ctor",""
+"@stdlib/stats/base/dists/f/kurtosis",""
+"@stdlib/stats/base/dists/f/mean",""
+"@stdlib/stats/base/dists/f/mode",""
+"@stdlib/stats/base/dists/f/pdf",""
+"@stdlib/stats/base/dists/f/quantile",""
+"@stdlib/stats/base/dists/f/skewness",""
+"@stdlib/stats/base/dists/f/stdev",""
+"@stdlib/stats/base/dists/f/variance",""
+"@stdlib/stats/base/dists/frechet/cdf",""
+"@stdlib/stats/base/dists/frechet/entropy",""
+"@stdlib/stats/base/dists/frechet/ctor",""
+"@stdlib/stats/base/dists/frechet/kurtosis",""
+"@stdlib/stats/base/dists/frechet/logcdf",""
+"@stdlib/stats/base/dists/frechet/logpdf",""
+"@stdlib/stats/base/dists/frechet/mean",""
+"@stdlib/stats/base/dists/frechet/median",""
+"@stdlib/stats/base/dists/frechet/mode",""
+"@stdlib/stats/base/dists/frechet/pdf",""
+"@stdlib/stats/base/dists/frechet/quantile",""
+"@stdlib/stats/base/dists/frechet/skewness",""
+"@stdlib/stats/base/dists/frechet/stdev",""
+"@stdlib/stats/base/dists/frechet/variance",""
+"@stdlib/stats/base/dists/gamma/cdf",""
+"@stdlib/stats/base/dists/gamma/entropy",""
+"@stdlib/stats/base/dists/gamma/ctor",""
+"@stdlib/stats/base/dists/gamma/kurtosis",""
+"@stdlib/stats/base/dists/gamma/logpdf",""
+"@stdlib/stats/base/dists/gamma/mean",""
+"@stdlib/stats/base/dists/gamma/mgf",""
+"@stdlib/stats/base/dists/gamma/mode",""
+"@stdlib/stats/base/dists/gamma/pdf",""
+"@stdlib/stats/base/dists/gamma/quantile",""
+"@stdlib/stats/base/dists/gamma/skewness",""
+"@stdlib/stats/base/dists/gamma/stdev",""
+"@stdlib/stats/base/dists/gamma/variance",""
+"@stdlib/stats/base/dists/geometric/cdf",""
+"@stdlib/stats/base/dists/geometric/entropy",""
+"@stdlib/stats/base/dists/geometric/ctor",""
+"@stdlib/stats/base/dists/geometric/kurtosis",""
+"@stdlib/stats/base/dists/geometric/logcdf",""
+"@stdlib/stats/base/dists/geometric/logpmf",""
+"@stdlib/stats/base/dists/geometric/mean",""
+"@stdlib/stats/base/dists/geometric/median",""
+"@stdlib/stats/base/dists/geometric/mgf",""
+"@stdlib/stats/base/dists/geometric/mode",""
+"@stdlib/stats/base/dists/geometric/pmf",""
+"@stdlib/stats/base/dists/geometric/quantile",""
+"@stdlib/stats/base/dists/geometric/skewness",""
+"@stdlib/stats/base/dists/geometric/stdev",""
+"@stdlib/stats/base/dists/geometric/variance",""
+"@stdlib/stats/base/dists/gumbel/cdf",""
+"@stdlib/stats/base/dists/gumbel/entropy",""
+"@stdlib/stats/base/dists/gumbel/ctor",""
+"@stdlib/stats/base/dists/gumbel/kurtosis",""
+"@stdlib/stats/base/dists/gumbel/logcdf",""
+"@stdlib/stats/base/dists/gumbel/logpdf",""
+"@stdlib/stats/base/dists/gumbel/mean",""
+"@stdlib/stats/base/dists/gumbel/median",""
+"@stdlib/stats/base/dists/gumbel/mgf",""
+"@stdlib/stats/base/dists/gumbel/mode",""
+"@stdlib/stats/base/dists/gumbel/pdf",""
+"@stdlib/stats/base/dists/gumbel/quantile",""
+"@stdlib/stats/base/dists/gumbel/skewness",""
+"@stdlib/stats/base/dists/gumbel/stdev",""
+"@stdlib/stats/base/dists/gumbel/variance",""
+"@stdlib/stats/base/dists/hypergeometric/cdf",""
+"@stdlib/stats/base/dists/hypergeometric/ctor",""
+"@stdlib/stats/base/dists/hypergeometric/kurtosis",""
+"@stdlib/stats/base/dists/hypergeometric/logpmf",""
+"@stdlib/stats/base/dists/hypergeometric/mean",""
+"@stdlib/stats/base/dists/hypergeometric/mode",""
+"@stdlib/stats/base/dists/hypergeometric/pmf",""
+"@stdlib/stats/base/dists/hypergeometric/quantile",""
+"@stdlib/stats/base/dists/hypergeometric/skewness",""
+"@stdlib/stats/base/dists/hypergeometric/stdev",""
+"@stdlib/stats/base/dists/hypergeometric/variance",""
+"@stdlib/stats/base/dists/invgamma/cdf",""
+"@stdlib/stats/base/dists/invgamma/entropy",""
+"@stdlib/stats/base/dists/invgamma/ctor",""
+"@stdlib/stats/base/dists/invgamma/kurtosis",""
+"@stdlib/stats/base/dists/invgamma/logpdf",""
+"@stdlib/stats/base/dists/invgamma/mean",""
+"@stdlib/stats/base/dists/invgamma/mode",""
+"@stdlib/stats/base/dists/invgamma/pdf",""
+"@stdlib/stats/base/dists/invgamma/quantile",""
+"@stdlib/stats/base/dists/invgamma/skewness",""
+"@stdlib/stats/base/dists/invgamma/stdev",""
+"@stdlib/stats/base/dists/invgamma/variance",""
+"@stdlib/stats/base/dists/kumaraswamy/cdf",""
+"@stdlib/stats/base/dists/kumaraswamy/ctor",""
+"@stdlib/stats/base/dists/kumaraswamy/kurtosis",""
+"@stdlib/stats/base/dists/kumaraswamy/logcdf",""
+"@stdlib/stats/base/dists/kumaraswamy/logpdf",""
+"@stdlib/stats/base/dists/kumaraswamy/mean",""
+"@stdlib/stats/base/dists/kumaraswamy/median",""
+"@stdlib/stats/base/dists/kumaraswamy/mode",""
+"@stdlib/stats/base/dists/kumaraswamy/pdf",""
+"@stdlib/stats/base/dists/kumaraswamy/quantile",""
+"@stdlib/stats/base/dists/kumaraswamy/skewness",""
+"@stdlib/stats/base/dists/kumaraswamy/stdev",""
+"@stdlib/stats/base/dists/kumaraswamy/variance",""
+"@stdlib/stats/base/dists/laplace/cdf",""
+"@stdlib/stats/base/dists/laplace/entropy",""
+"@stdlib/stats/base/dists/laplace/kurtosis",""
+"@stdlib/stats/base/dists/laplace/ctor",""
+"@stdlib/stats/base/dists/laplace/logcdf",""
+"@stdlib/stats/base/dists/laplace/logpdf",""
+"@stdlib/stats/base/dists/laplace/mean",""
+"@stdlib/stats/base/dists/laplace/median",""
+"@stdlib/stats/base/dists/laplace/mgf",""
+"@stdlib/stats/base/dists/laplace/mode",""
+"@stdlib/stats/base/dists/laplace/pdf",""
+"@stdlib/stats/base/dists/laplace/quantile",""
+"@stdlib/stats/base/dists/laplace/skewness",""
+"@stdlib/stats/base/dists/laplace/stdev",""
+"@stdlib/stats/base/dists/laplace/variance",""
+"@stdlib/stats/base/dists/levy/cdf",""
+"@stdlib/stats/base/dists/levy/entropy",""
+"@stdlib/stats/base/dists/levy/ctor",""
+"@stdlib/stats/base/dists/levy/logcdf",""
+"@stdlib/stats/base/dists/levy/logpdf",""
+"@stdlib/stats/base/dists/levy/mean",""
+"@stdlib/stats/base/dists/levy/median",""
+"@stdlib/stats/base/dists/levy/mode",""
+"@stdlib/stats/base/dists/levy/pdf",""
+"@stdlib/stats/base/dists/levy/quantile",""
+"@stdlib/stats/base/dists/levy/stdev",""
+"@stdlib/stats/base/dists/levy/variance",""
+"@stdlib/stats/base/dists/logistic/cdf",""
+"@stdlib/stats/base/dists/logistic/entropy",""
+"@stdlib/stats/base/dists/logistic/kurtosis",""
+"@stdlib/stats/base/dists/logistic/logcdf",""
+"@stdlib/stats/base/dists/logistic/ctor",""
+"@stdlib/stats/base/dists/logistic/logpdf",""
+"@stdlib/stats/base/dists/logistic/mean",""
+"@stdlib/stats/base/dists/logistic/median",""
+"@stdlib/stats/base/dists/logistic/mgf",""
+"@stdlib/stats/base/dists/logistic/mode",""
+"@stdlib/stats/base/dists/logistic/pdf",""
+"@stdlib/stats/base/dists/logistic/quantile",""
+"@stdlib/stats/base/dists/logistic/skewness",""
+"@stdlib/stats/base/dists/logistic/stdev",""
+"@stdlib/stats/base/dists/logistic/variance",""
+"@stdlib/stats/base/dists/lognormal/cdf",""
+"@stdlib/stats/base/dists/lognormal/entropy",""
+"@stdlib/stats/base/dists/lognormal/kurtosis",""
+"@stdlib/stats/base/dists/lognormal/ctor",""
+"@stdlib/stats/base/dists/lognormal/logpdf",""
+"@stdlib/stats/base/dists/lognormal/mean",""
+"@stdlib/stats/base/dists/lognormal/median",""
+"@stdlib/stats/base/dists/lognormal/mode",""
+"@stdlib/stats/base/dists/lognormal/pdf",""
+"@stdlib/stats/base/dists/lognormal/quantile",""
+"@stdlib/stats/base/dists/lognormal/skewness",""
+"@stdlib/stats/base/dists/lognormal/stdev",""
+"@stdlib/stats/base/dists/lognormal/variance",""
+"@stdlib/stats/base/dists/negative-binomial/cdf",""
+"@stdlib/stats/base/dists/negative-binomial/kurtosis",""
+"@stdlib/stats/base/dists/negative-binomial/logpmf",""
+"@stdlib/stats/base/dists/negative-binomial/mean",""
+"@stdlib/stats/base/dists/negative-binomial/mgf",""
+"@stdlib/stats/base/dists/negative-binomial/mode",""
+"@stdlib/stats/base/dists/negative-binomial/ctor",""
+"@stdlib/stats/base/dists/negative-binomial/pmf",""
+"@stdlib/stats/base/dists/negative-binomial/quantile",""
+"@stdlib/stats/base/dists/negative-binomial/skewness",""
+"@stdlib/stats/base/dists/negative-binomial/stdev",""
+"@stdlib/stats/base/dists/negative-binomial/variance",""
+"@stdlib/stats/base/dists/normal/cdf",""
+"@stdlib/stats/base/dists/normal/entropy",""
+"@stdlib/stats/base/dists/normal/kurtosis",""
+"@stdlib/stats/base/dists/normal/logpdf",""
+"@stdlib/stats/base/dists/normal/mean",""
+"@stdlib/stats/base/dists/normal/median",""
+"@stdlib/stats/base/dists/normal/mgf",""
+"@stdlib/stats/base/dists/normal/mode",""
+"@stdlib/stats/base/dists/normal/ctor",""
+"@stdlib/stats/base/dists/normal/pdf",""
+"@stdlib/stats/base/dists/normal/quantile",""
+"@stdlib/stats/base/dists/normal/skewness",""
+"@stdlib/stats/base/dists/normal/stdev",""
+"@stdlib/stats/base/dists/normal/variance",""
+"@stdlib/stats/base/dists/pareto-type1/cdf",""
+"@stdlib/stats/base/dists/pareto-type1/entropy",""
+"@stdlib/stats/base/dists/pareto-type1/kurtosis",""
+"@stdlib/stats/base/dists/pareto-type1/logcdf",""
+"@stdlib/stats/base/dists/pareto-type1/logpdf",""
+"@stdlib/stats/base/dists/pareto-type1/mean",""
+"@stdlib/stats/base/dists/pareto-type1/median",""
+"@stdlib/stats/base/dists/pareto-type1/mode",""
+"@stdlib/stats/base/dists/pareto-type1/ctor",""
+"@stdlib/stats/base/dists/pareto-type1/pdf",""
+"@stdlib/stats/base/dists/pareto-type1/quantile",""
+"@stdlib/stats/base/dists/pareto-type1/skewness",""
+"@stdlib/stats/base/dists/pareto-type1/variance",""
+"@stdlib/stats/base/dists/poisson/cdf",""
+"@stdlib/stats/base/dists/poisson/entropy",""
+"@stdlib/stats/base/dists/poisson/kurtosis",""
+"@stdlib/stats/base/dists/poisson/logpmf",""
+"@stdlib/stats/base/dists/poisson/mean",""
+"@stdlib/stats/base/dists/poisson/median",""
+"@stdlib/stats/base/dists/poisson/mgf",""
+"@stdlib/stats/base/dists/poisson/mode",""
+"@stdlib/stats/base/dists/poisson/pmf",""
+"@stdlib/stats/base/dists/poisson/ctor",""
+"@stdlib/stats/base/dists/poisson/quantile",""
+"@stdlib/stats/base/dists/poisson/skewness",""
+"@stdlib/stats/base/dists/poisson/stdev",""
+"@stdlib/stats/base/dists/poisson/variance",""
+"@stdlib/stats/base/dists/rayleigh/cdf",""
+"@stdlib/stats/base/dists/rayleigh/entropy",""
+"@stdlib/stats/base/dists/rayleigh/kurtosis",""
+"@stdlib/stats/base/dists/rayleigh/logcdf",""
+"@stdlib/stats/base/dists/rayleigh/logpdf",""
+"@stdlib/stats/base/dists/rayleigh/mean",""
+"@stdlib/stats/base/dists/rayleigh/median",""
+"@stdlib/stats/base/dists/rayleigh/mgf",""
+"@stdlib/stats/base/dists/rayleigh/mode",""
+"@stdlib/stats/base/dists/rayleigh/pdf",""
+"@stdlib/stats/base/dists/rayleigh/quantile",""
+"@stdlib/stats/base/dists/rayleigh/ctor",""
+"@stdlib/stats/base/dists/rayleigh/skewness",""
+"@stdlib/stats/base/dists/rayleigh/stdev",""
+"@stdlib/stats/base/dists/rayleigh/variance",""
+"@stdlib/stats/base/dists/t/cdf",""
+"@stdlib/stats/base/dists/t/entropy",""
+"@stdlib/stats/base/dists/t/kurtosis",""
+"@stdlib/stats/base/dists/t/mean",""
+"@stdlib/stats/base/dists/t/median",""
+"@stdlib/stats/base/dists/t/mode",""
+"@stdlib/stats/base/dists/t/pdf",""
+"@stdlib/stats/base/dists/t/quantile",""
+"@stdlib/stats/base/dists/t/skewness",""
+"@stdlib/stats/base/dists/t/stdev",""
+"@stdlib/stats/base/dists/t/ctor",""
+"@stdlib/stats/base/dists/t/variance",""
+"@stdlib/stats/base/dists/triangular/cdf",""
+"@stdlib/stats/base/dists/triangular/entropy",""
+"@stdlib/stats/base/dists/triangular/kurtosis",""
+"@stdlib/stats/base/dists/triangular/logcdf",""
+"@stdlib/stats/base/dists/triangular/logpdf",""
+"@stdlib/stats/base/dists/triangular/mean",""
+"@stdlib/stats/base/dists/triangular/median",""
+"@stdlib/stats/base/dists/triangular/mgf",""
+"@stdlib/stats/base/dists/triangular/mode",""
+"@stdlib/stats/base/dists/triangular/pdf",""
+"@stdlib/stats/base/dists/triangular/quantile",""
+"@stdlib/stats/base/dists/triangular/skewness",""
+"@stdlib/stats/base/dists/triangular/stdev",""
+"@stdlib/stats/base/dists/triangular/ctor",""
+"@stdlib/stats/base/dists/triangular/variance",""
+"@stdlib/stats/base/dists/uniform/cdf",""
+"@stdlib/stats/base/dists/uniform/entropy",""
+"@stdlib/stats/base/dists/uniform/kurtosis",""
+"@stdlib/stats/base/dists/uniform/logcdf",""
+"@stdlib/stats/base/dists/uniform/logpdf",""
+"@stdlib/stats/base/dists/uniform/mean",""
+"@stdlib/stats/base/dists/uniform/median",""
+"@stdlib/stats/base/dists/uniform/mgf",""
+"@stdlib/stats/base/dists/uniform/pdf",""
+"@stdlib/stats/base/dists/uniform/quantile",""
+"@stdlib/stats/base/dists/uniform/skewness",""
+"@stdlib/stats/base/dists/uniform/stdev",""
+"@stdlib/stats/base/dists/uniform/ctor",""
+"@stdlib/stats/base/dists/uniform/variance",""
+"@stdlib/stats/base/dists/weibull/cdf",""
+"@stdlib/stats/base/dists/weibull/entropy",""
+"@stdlib/stats/base/dists/weibull/kurtosis",""
+"@stdlib/stats/base/dists/weibull/logcdf",""
+"@stdlib/stats/base/dists/weibull/logpdf",""
+"@stdlib/stats/base/dists/weibull/mean",""
+"@stdlib/stats/base/dists/weibull/median",""
+"@stdlib/stats/base/dists/weibull/mgf",""
+"@stdlib/stats/base/dists/weibull/mode",""
+"@stdlib/stats/base/dists/weibull/pdf",""
+"@stdlib/stats/base/dists/weibull/quantile",""
+"@stdlib/stats/base/dists/weibull/skewness",""
+"@stdlib/stats/base/dists/weibull/stdev",""
+"@stdlib/stats/base/dists/weibull/variance",""
+"@stdlib/stats/base/dists/weibull/ctor",""
+"@stdlib/math/base/special/ellipe","@stdlib/math/base/special/ellipk"
+"@stdlib/math/base/special/ellipk","@stdlib/math/base/special/ellipe"
+"@stdlib/math/base/utils/float64-epsilon-difference","@stdlib/math/base/utils/absolute-difference,@stdlib/math/base/utils/relative-difference"
+"@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc,@stdlib/math/base/special/erfinv,@stdlib/math/base/special/erfcinv"
+"@stdlib/math/base/special/erfc","@stdlib/math/base/special/erf,@stdlib/math/base/special/erfinv,@stdlib/math/base/special/erfcinv"
+"@stdlib/math/base/special/erfcinv","@stdlib/math/base/special/erf,@stdlib/math/base/special/erfc,@stdlib/math/base/special/erfinv"
+"@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erf,@stdlib/math/base/special/erfc,@stdlib/math/base/special/erfcinv"
+"@stdlib/math/base/special/dirichlet-eta",""
+"@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/evalrational"
+"@stdlib/math/base/tools/evalrational","@stdlib/math/base/tools/evalpoly"
+"@stdlib/math/base/special/exp","@stdlib/math/base/special/exp10,@stdlib/math/base/special/exp2,@stdlib/math/base/special/expm1,@stdlib/math/base/special/ln"
+"@stdlib/math/base/special/exp2","@stdlib/math/base/special/exp,@stdlib/math/base/special/exp10"
+"@stdlib/math/base/special/exp10","@stdlib/math/base/special/exp,@stdlib/math/base/special/exp2"
+"@stdlib/math/base/special/expit","@stdlib/math/base/special/exp,@stdlib/math/base/special/logit"
+"@stdlib/math/base/special/expm1","@stdlib/math/base/special/exp,@stdlib/math/base/special/expm1rel"
+"@stdlib/math/base/special/expm1rel","@stdlib/math/base/special/exp,@stdlib/math/base/special/expm1"
+"@stdlib/number/float64/base/exponent","@stdlib/number/float32/base/exponent"
+"@stdlib/number/float32/base/exponent","@stdlib/number/float64/base/exponent"
+"@stdlib/math/base/special/factorial","@stdlib/math/base/special/factorialln"
+"@stdlib/math/base/special/factorialln","@stdlib/math/base/special/factorial"
+"@stdlib/math/base/special/falling-factorial","@stdlib/math/base/special/rising-factorial"
+"@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/binet,@stdlib/math/base/special/fibonacci-index,@stdlib/math/base/special/lucas,@stdlib/math/base/special/negafibonacci"
+"@stdlib/math/base/special/fibonacci-index","@stdlib/math/base/special/fibonacci"
+"@stdlib/math/base/tools/fibpoly","@stdlib/math/base/tools/evalpoly,@stdlib/math/base/tools/lucaspoly"
+"@stdlib/math/base/special/flipsign","@stdlib/math/base/special/copysign"
+"@stdlib/number/float32/base/to-int32","@stdlib/number/float32/base/to-uint32"
+"@stdlib/number/float32/base/to-uint32","@stdlib/number/float32/base/to-int32"
+"@stdlib/number/float64/base/to-float32",""
+"@stdlib/number/float64/base/to-int32","@stdlib/number/float64/base/to-uint32"
+"@stdlib/number/float64/base/to-uint32","@stdlib/number/float64/base/to-int32"
+"@stdlib/math/base/special/floor","@stdlib/math/base/special/ceil,@stdlib/math/base/special/round"
+"@stdlib/math/base/special/floor2","@stdlib/math/base/special/ceil2,@stdlib/math/base/special/floor,@stdlib/math/base/special/floor10,@stdlib/math/base/special/round2"
+"@stdlib/math/base/special/floor10","@stdlib/math/base/special/ceil10,@stdlib/math/base/special/floor,@stdlib/math/base/special/floor2,@stdlib/math/base/special/round10"
+"@stdlib/math/base/special/floorb","@stdlib/math/base/special/ceilb,@stdlib/math/base/special/floor,@stdlib/math/base/special/floorn,@stdlib/math/base/special/roundb"
+"@stdlib/math/base/special/floorn","@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floor,@stdlib/math/base/special/floorb,@stdlib/math/base/special/roundn"
+"@stdlib/math/base/special/floorsd","@stdlib/math/base/special/ceilsd,@stdlib/math/base/special/floor,@stdlib/math/base/special/roundsd,@stdlib/math/base/special/truncsd"
+"@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnelc,@stdlib/math/base/special/fresnels"
+"@stdlib/math/base/special/fresnelc","@stdlib/math/base/special/fresnel,@stdlib/math/base/special/fresnels"
+"@stdlib/math/base/special/fresnels","@stdlib/math/base/special/fresnel,@stdlib/math/base/special/fresnelc"
+"@stdlib/math/base/special/frexp","@stdlib/math/base/special/ldexp"
+"@stdlib/number/float64/base/from-binary-string","@stdlib/number/float32/base/from-binary-string,@stdlib/number/float64/base/to-binary-string"
+"@stdlib/number/float32/base/from-binary-string","@stdlib/number/float32/base/to-binary-string,@stdlib/number/float64/base/from-binary-string"
+"@stdlib/number/uint8/base/from-binary-string","@stdlib/number/uint16/base/from-binary-string,@stdlib/number/uint32/base/from-binary-string,@stdlib/number/uint8/base/to-binary-string"
+"@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint16/base/to-binary-string,@stdlib/number/uint32/base/from-binary-string,@stdlib/number/uint8/base/from-binary-string"
+"@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint16/base/from-binary-string,@stdlib/number/uint32/base/to-binary-string,@stdlib/number/uint8/base/from-binary-string"
+"@stdlib/number/float32/base/from-word","@stdlib/number/float64/base/from-words"
+"@stdlib/number/float64/base/from-words","@stdlib/number/float32/base/from-word"
+"@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1,@stdlib/math/base/special/gammainc,@stdlib/math/base/special/gammaincinv,@stdlib/math/base/special/gammaln"
+"@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gammainc,@stdlib/math/base/special/gammaincinv,@stdlib/math/base/special/gammaln"
+"@stdlib/math/base/special/gamma-delta-ratio","@stdlib/math/base/special/gamma"
+"@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gamma1pm1,@stdlib/math/base/special/gammaincinv,@stdlib/math/base/special/gammaln"
+"@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gamma1pm1,@stdlib/math/base/special/gammainc,@stdlib/math/base/special/gammaln"
+"@stdlib/math/base/special/gamma-lanczos-sum","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled"
+"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gamma-lanczos-sum"
+"@stdlib/math/base/special/gammaln","@stdlib/math/base/special/gamma,@stdlib/math/base/special/gammainc,@stdlib/math/base/special/gammaincinv"
+"@stdlib/blas/base/gasum","@stdlib/blas/base/dasum,@stdlib/blas/base/sasum"
+"@stdlib/blas/base/gaxpy","@stdlib/blas/base/daxpy,@stdlib/blas/base/saxpy"
+"@stdlib/math/base/special/gcd","@stdlib/math/base/special/lcm"
+"@stdlib/blas/base/gcopy","@stdlib/blas/base/dcopy"
+"@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/get-low-word,@stdlib/number/float64/base/set-high-word"
+"@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/get-high-word,@stdlib/number/float64/base/set-high-word"
+"@stdlib/math/base/special/hacovercos","@stdlib/math/base/special/hacoversin,@stdlib/math/base/special/havercos"
+"@stdlib/math/base/special/hacoversin","@stdlib/math/base/special/hacovercos,@stdlib/math/base/special/haversin"
+"@stdlib/math/base/special/havercos","@stdlib/math/base/special/haversin,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/haversin","@stdlib/math/base/special/havercos,@stdlib/math/base/special/versin"
+"@stdlib/math/base/special/heaviside","@stdlib/math/base/special/ramp"
+"@stdlib/math/base/tools/hermitepoly","@stdlib/math/base/tools/evalpoly,@stdlib/math/base/tools/normhermitepoly"
+"@stdlib/math/base/special/hypot",""
+"@stdlib/math/base/special/imul","@stdlib/math/base/special/imuldw,@stdlib/math/base/special/uimul"
+"@stdlib/math/base/special/imuldw","@stdlib/math/base/special/imul,@stdlib/math/base/special/uimuldw"
+"@stdlib/number/int32/base/to-uint32","@stdlib/number/uint32/base/to-int32"
+"@stdlib/math/base/special/inv","@stdlib/math/base/special/pow"
+"@stdlib/math/base/assert/is-even","@stdlib/math/base/assert/is-odd"
+"@stdlib/math/base/assert/int32-is-even","@stdlib/math/base/assert/is-even,@stdlib/math/base/assert/int32-is-odd"
+"@stdlib/math/base/assert/is-finite","@stdlib/math/base/assert/is-infinite"
+"@stdlib/math/base/assert/is-infinite","@stdlib/math/base/assert/is-finite"
+"@stdlib/math/base/assert/is-integer",""
+"@stdlib/math/base/assert/is-nan",""
+"@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-integer,@stdlib/math/base/assert/is-nonnegative-integer,@stdlib/math/base/assert/is-nonpositive-integer,@stdlib/math/base/assert/is-positive-integer"
+"@stdlib/math/base/assert/is-negative-zero","@stdlib/math/base/assert/is-positive-zero"
+"@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-integer,@stdlib/math/base/assert/is-negative-integer,@stdlib/math/base/assert/is-nonpositive-integer,@stdlib/math/base/assert/is-positive-integer"
+"@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-integer,@stdlib/math/base/assert/is-negative-integer,@stdlib/math/base/assert/is-nonnegative-integer,@stdlib/math/base/assert/is-positive-integer"
+"@stdlib/math/base/assert/is-odd","@stdlib/math/base/assert/is-even"
+"@stdlib/math/base/assert/int32-is-odd","@stdlib/math/base/assert/int32-is-even,@stdlib/math/base/assert/is-odd"
+"@stdlib/math/base/assert/is-positive-integer","@stdlib/math/base/assert/is-integer,@stdlib/math/base/assert/is-negative-integer,@stdlib/math/base/assert/is-nonnegative-integer,@stdlib/math/base/assert/is-nonpositive-integer"
+"@stdlib/math/base/assert/is-positive-zero","@stdlib/math/base/assert/is-negative-zero"
+"@stdlib/math/base/assert/uint32-is-pow2",""
+"@stdlib/math/base/assert/is-probability",""
+"@stdlib/math/base/assert/is-safe-integer",""
+"@stdlib/math/base/special/kernel-betainc","@stdlib/math/base/special/betainc"
+"@stdlib/math/base/special/kernel-betaincinv","@stdlib/math/base/special/betaincinv"
+"@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/cos,@stdlib/math/base/special/kernel-sin,@stdlib/math/base/special/kernel-tan"
+"@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/kernel-cos,@stdlib/math/base/special/kernel-tan,@stdlib/math/base/special/sin"
+"@stdlib/math/base/special/kernel-tan","@stdlib/math/base/special/kernel-cos,@stdlib/math/base/special/kernel-sin,@stdlib/math/base/special/tan"
+"@stdlib/math/base/special/kronecker-delta","@stdlib/math/base/special/dirac-delta"
+"@stdlib/math/base/special/lcm","@stdlib/math/base/special/gcd"
+"@stdlib/math/base/special/ldexp","@stdlib/math/base/special/frexp"
+"@stdlib/math/base/special/ln","@stdlib/math/base/special/exp,@stdlib/math/base/special/log10,@stdlib/math/base/special/log1p,@stdlib/math/base/special/log2"
+"@stdlib/math/base/special/log","@stdlib/math/base/special/exp,@stdlib/math/base/special/ln,@stdlib/math/base/special/log10,@stdlib/math/base/special/log1p,@stdlib/math/base/special/log2"
+"@stdlib/math/base/special/log1mexp","@stdlib/math/base/special/exp,@stdlib/math/base/special/ln,@stdlib/math/base/special/log1p,@stdlib/math/base/special/log1pexp"
+"@stdlib/math/base/special/log1p","@stdlib/math/base/special/ln,@stdlib/math/base/special/log"
+"@stdlib/math/base/special/log1pexp","@stdlib/math/base/special/exp,@stdlib/math/base/special/ln,@stdlib/math/base/special/log1mexp,@stdlib/math/base/special/log1p"
+"@stdlib/math/base/special/log2","@stdlib/math/base/special/exp2,@stdlib/math/base/special/ln,@stdlib/math/base/special/log"
+"@stdlib/math/base/special/log10","@stdlib/math/base/special/exp10,@stdlib/math/base/special/ln,@stdlib/math/base/special/log"
+"@stdlib/math/base/special/logaddexp","@stdlib/math/base/special/exp,@stdlib/math/base/special/ln"
+"@stdlib/math/base/special/logit",""
+"@stdlib/math/base/special/lucas","@stdlib/math/base/special/fibonacci,@stdlib/math/base/special/negalucas"
+"@stdlib/math/base/tools/lucaspoly","@stdlib/math/base/tools/evalpoly,@stdlib/math/base/tools/fibpoly"
+"@stdlib/math/base/special/max","@stdlib/math/base/special/maxabs,@stdlib/math/base/special/min"
+"@stdlib/math/base/special/maxabs","@stdlib/math/base/special/max,@stdlib/math/base/special/minabs"
+"@stdlib/math/base/special/min","@stdlib/math/base/special/max,@stdlib/math/base/special/minabs"
+"@stdlib/math/base/special/minabs","@stdlib/math/base/special/maxabs,@stdlib/math/base/special/min"
+"@stdlib/math/base/special/minmax","@stdlib/math/base/special/max,@stdlib/math/base/special/min,@stdlib/math/base/special/minmaxabs"
+"@stdlib/math/base/special/minmaxabs","@stdlib/math/base/special/maxabs,@stdlib/math/base/special/minabs,@stdlib/math/base/special/minmax"
+"@stdlib/math/base/special/modf",""
+"@stdlib/ndarray/base/ctor","@stdlib/ndarray/array,@stdlib/ndarray/ctor"
+"@stdlib/ndarray/base/memoized-ctor","@stdlib/ndarray/array,@stdlib/ndarray/base/ctor,@stdlib/ndarray/ctor,@stdlib/ndarray/memoized-ctor"
+"@stdlib/math/base/special/negafibonacci","@stdlib/math/base/special/fibonacci,@stdlib/math/base/special/negalucas"
+"@stdlib/math/base/special/negalucas","@stdlib/math/base/special/fibonacci,@stdlib/math/base/special/lucas,@stdlib/math/base/special/negafibonacci"
+"@stdlib/math/base/special/nonfibonacci","@stdlib/math/base/special/fibonacci"
+"@stdlib/number/float64/base/normalize","@stdlib/number/float32/base/normalize"
+"@stdlib/number/float32/base/normalize","@stdlib/number/float64/base/normalize"
+"@stdlib/math/base/tools/normhermitepoly","@stdlib/math/base/tools/evalpoly,@stdlib/math/base/tools/hermitepoly"
+"@stdlib/math/base/special/pdiff",""
+"@stdlib/math/base/special/polygamma","@stdlib/math/base/special/trigamma,@stdlib/math/base/special/digamma,@stdlib/math/base/special/gamma"
+"@stdlib/math/base/special/pow","@stdlib/math/base/special/exp,@stdlib/math/base/special/powm1"
+"@stdlib/math/base/special/powm1","@stdlib/math/base/special/pow"
+"@stdlib/math/base/special/rad2deg","@stdlib/math/base/special/deg2rad"
+"@stdlib/math/base/special/ramp","@stdlib/math/base/special/heaviside"
+"@stdlib/random/base/arcsine","@stdlib/random/base/beta"
+"@stdlib/random/base/bernoulli","@stdlib/random/base/binomial"
+"@stdlib/random/base/beta",""
+"@stdlib/random/base/betaprime",""
+"@stdlib/random/base/binomial",""
+"@stdlib/random/base/box-muller",""
+"@stdlib/random/base/cauchy",""
+"@stdlib/random/base/chi",""
+"@stdlib/random/base/chisquare",""
+"@stdlib/random/base/cosine",""
+"@stdlib/random/base/discrete-uniform",""
+"@stdlib/random/base/erlang",""
+"@stdlib/random/base/exponential",""
+"@stdlib/random/base/f",""
+"@stdlib/random/base/frechet",""
+"@stdlib/random/base/gamma",""
+"@stdlib/random/base/geometric",""
+"@stdlib/random/base/gumbel",""
+"@stdlib/random/base/hypergeometric",""
+"@stdlib/random/base/improved-ziggurat",""
+"@stdlib/random/base/invgamma",""
+"@stdlib/random/base/kumaraswamy",""
+"@stdlib/random/base/laplace",""
+"@stdlib/random/base/levy",""
+"@stdlib/random/base/logistic",""
+"@stdlib/random/base/lognormal",""
+"@stdlib/random/base/minstd","@stdlib/random/base/minstd-shuffle,@stdlib/random/base/mt19937,@stdlib/random/base/randi"
+"@stdlib/random/base/minstd-shuffle","@stdlib/random/base/minstd,@stdlib/random/base/mt19937,@stdlib/random/base/randi"
+"@stdlib/random/base/mt19937","@stdlib/random/base/minstd,@stdlib/random/base/randi"
+"@stdlib/random/base/negative-binomial",""
+"@stdlib/random/base/normal",""
+"@stdlib/random/base/pareto-type1",""
+"@stdlib/random/base/poisson",""
+"@stdlib/random/base/randi","@stdlib/random/base/minstd,@stdlib/random/base/minstd-shuffle,@stdlib/random/base/mt19937"
+"@stdlib/random/base/randn","@stdlib/random/base/improved-ziggurat,@stdlib/random/base/randu"
+"@stdlib/random/base/randu","@stdlib/random/base/discrete-uniform,@stdlib/random/base/randn"
+"@stdlib/random/base/rayleigh",""
+"@stdlib/random/base/t",""
+"@stdlib/random/base/triangular",""
+"@stdlib/random/base/uniform","@stdlib/random/base/discrete-uniform,@stdlib/random/base/randu"
+"@stdlib/random/base/weibull",""
+"@stdlib/math/base/utils/relative-difference","@stdlib/math/base/utils/absolute-difference,@stdlib/math/base/utils/float64-epsilon-difference"
+"@stdlib/math/base/special/rempio2",""
+"@stdlib/math/base/special/rising-factorial","@stdlib/math/base/special/falling-factorial"
+"@stdlib/number/uint32/base/rotl","@stdlib/number/uint32/base/rotr"
+"@stdlib/number/uint32/base/rotr","@stdlib/number/uint32/base/rotl"
+"@stdlib/math/base/special/round","@stdlib/math/base/special/ceil,@stdlib/math/base/special/floor,@stdlib/math/base/special/roundn,@stdlib/math/base/special/trunc"
+"@stdlib/math/base/special/round2","@stdlib/math/base/special/ceil2,@stdlib/math/base/special/floor2,@stdlib/math/base/special/round,@stdlib/math/base/special/round10"
+"@stdlib/math/base/special/round10","@stdlib/math/base/special/ceil10,@stdlib/math/base/special/floor10,@stdlib/math/base/special/round,@stdlib/math/base/special/round2"
+"@stdlib/math/base/special/roundb","@stdlib/math/base/special/ceilb,@stdlib/math/base/special/floorb,@stdlib/math/base/special/round,@stdlib/math/base/special/roundn"
+"@stdlib/math/base/special/roundn","@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floorn,@stdlib/math/base/special/round,@stdlib/math/base/special/roundb"
+"@stdlib/math/base/special/roundsd","@stdlib/math/base/special/ceilsd,@stdlib/math/base/special/floorsd,@stdlib/math/base/special/round,@stdlib/math/base/special/truncsd"
+"@stdlib/math/base/special/rsqrt","@stdlib/math/base/special/sqrt"
+"@stdlib/blas/base/sasum","@stdlib/blas/base/dasum"
+"@stdlib/blas/base/saxpy","@stdlib/blas/base/daxpy"
+"@stdlib/blas/base/scopy","@stdlib/blas/base/dcopy"
+"@stdlib/number/float64/base/set-high-word","@stdlib/number/float64/base/get-high-word,@stdlib/number/float64/base/set-low-word"
+"@stdlib/number/float64/base/set-low-word","@stdlib/number/float64/base/get-low-word,@stdlib/number/float64/base/set-high-word"
+"@stdlib/math/base/special/sici",""
+"@stdlib/number/float64/base/signbit","@stdlib/number/float32/base/signbit"
+"@stdlib/number/float32/base/signbit","@stdlib/number/float64/base/signbit"
+"@stdlib/number/float32/base/significand",""
+"@stdlib/math/base/special/signum",""
+"@stdlib/math/base/special/sin","@stdlib/math/base/special/cos,@stdlib/math/base/special/sinpi,@stdlib/math/base/special/tan"
+"@stdlib/math/base/special/sinc","@stdlib/math/base/special/sin"
+"@stdlib/math/base/special/sincos","@stdlib/math/base/special/cos,@stdlib/math/base/special/sin,@stdlib/math/base/special/sincospi"
+"@stdlib/math/base/special/sincospi","@stdlib/math/base/special/cospi,@stdlib/math/base/special/sincos,@stdlib/math/base/special/sinpi"
+"@stdlib/math/base/special/sinh","@stdlib/math/base/special/cosh,@stdlib/math/base/special/sin,@stdlib/math/base/special/tanh"
+"@stdlib/math/base/special/sinpi","@stdlib/math/base/special/sin"
+"@stdlib/math/base/special/spence",""
+"@stdlib/math/base/special/sqrt","@stdlib/math/base/special/cbrt,@stdlib/math/base/special/rsqrt"
+"@stdlib/math/base/special/sqrt1pm1","@stdlib/math/base/special/sqrt"
+"@stdlib/math/base/tools/sum-series",""
+"@stdlib/math/base/special/tan","@stdlib/math/base/special/cos,@stdlib/math/base/special/sin"
+"@stdlib/math/base/special/tanh","@stdlib/math/base/special/cosh,@stdlib/math/base/special/sinh,@stdlib/math/base/special/tan"
+"@stdlib/number/float64/base/to-binary-string","@stdlib/number/float64/base/from-binary-string,@stdlib/number/float32/base/to-binary-string"
+"@stdlib/number/float32/base/to-binary-string","@stdlib/number/float32/base/from-binary-string,@stdlib/number/float64/base/to-binary-string"
+"@stdlib/number/uint8/base/to-binary-string","@stdlib/number/float64/base/to-binary-string"
+"@stdlib/number/uint16/base/to-binary-string","@stdlib/number/float64/base/to-binary-string"
+"@stdlib/number/uint32/base/to-binary-string","@stdlib/number/float64/base/to-binary-string"
+"@stdlib/number/float32/base/to-word","@stdlib/number/float32/base/from-word,@stdlib/number/float64/base/to-words"
+"@stdlib/number/float64/base/to-words","@stdlib/number/float64/base/from-words,@stdlib/number/float32/base/to-word"
+"@stdlib/math/base/special/trigamma","@stdlib/math/base/special/digamma,@stdlib/math/base/special/gamma"
+"@stdlib/math/base/special/trunc","@stdlib/math/base/special/ceil,@stdlib/math/base/special/floor,@stdlib/math/base/special/round"
+"@stdlib/math/base/special/trunc2","@stdlib/math/base/special/ceil2,@stdlib/math/base/special/floor2,@stdlib/math/base/special/round2,@stdlib/math/base/special/trunc,@stdlib/math/base/special/trunc10"
+"@stdlib/math/base/special/trunc10","@stdlib/math/base/special/ceil10,@stdlib/math/base/special/floor10,@stdlib/math/base/special/round10,@stdlib/math/base/special/trunc,@stdlib/math/base/special/trunc2"
+"@stdlib/math/base/special/truncb","@stdlib/math/base/special/ceilb,@stdlib/math/base/special/floorb,@stdlib/math/base/special/roundb,@stdlib/math/base/special/trunc,@stdlib/math/base/special/truncn"
+"@stdlib/math/base/special/truncn","@stdlib/math/base/special/ceiln,@stdlib/math/base/special/floorn,@stdlib/math/base/special/roundn,@stdlib/math/base/special/trunc,@stdlib/math/base/special/truncb"
+"@stdlib/math/base/special/truncsd","@stdlib/math/base/special/ceilsd,@stdlib/math/base/special/floorsd,@stdlib/math/base/special/roundsd,@stdlib/math/base/special/trunc"
+"@stdlib/math/base/special/uimul","@stdlib/math/base/special/imul"
+"@stdlib/math/base/special/uimuldw","@stdlib/math/base/special/imuldw,@stdlib/math/base/special/uimul"
+"@stdlib/number/uint32/base/to-int32",""
+"@stdlib/math/base/special/vercos","@stdlib/math/base/special/cos,@stdlib/math/base/special/versin"
+"@stdlib/math/base/special/versin","@stdlib/math/base/special/cos,@stdlib/math/base/special/sin,@stdlib/math/base/special/vercos"
+"@stdlib/math/base/special/wrap","@stdlib/math/base/special/clamp"
+"@stdlib/math/base/special/xlog1py","@stdlib/math/base/special/log1p,@stdlib/math/base/special/xlogy"
+"@stdlib/math/base/special/xlogy","@stdlib/math/base/special/ln,@stdlib/math/base/special/xlog1py"
+"@stdlib/math/base/special/riemann-zeta",""
+"@stdlib/datasets/berndt-cps-wages-1985",""
+"@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by,@stdlib/utils/bifurcate-own,@stdlib/utils/group"
+"@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate,@stdlib/utils/group-by"
+"@stdlib/utils/async/bifurcate-by","@stdlib/utils/bifurcate-by,@stdlib/utils/async/group-by"
+"@stdlib/utils/bifurcate-in","@stdlib/utils/bifurcate,@stdlib/utils/bifurcate-by,@stdlib/utils/bifurcate-own,@stdlib/utils/group-in"
+"@stdlib/utils/bifurcate-own","@stdlib/utils/bifurcate,@stdlib/utils/bifurcate-by,@stdlib/utils/bifurcate-in,@stdlib/utils/group-own"
+"@stdlib/stats/binomial-test",""
+"@stdlib/buffer/ctor","@stdlib/array/buffer"
+"@stdlib/buffer/to-json","@stdlib/array/to-json,@stdlib/buffer/reviver"
+"@stdlib/string/capitalize","@stdlib/string/uncapitalize,@stdlib/string/uppercase"
+"@stdlib/utils/capitalize-keys","@stdlib/utils/uncapitalize-keys,@stdlib/utils/uppercase-keys"
+"@stdlib/constants/math/float64-catalan",""
+"@stdlib/constants/math/float64-cbrt-eps","@stdlib/constants/math/float64-eps,@stdlib/constants/math/float64-sqrt-eps"
+"@stdlib/process/chdir","@stdlib/process/cwd"
+"@stdlib/stats/chi2gof",""
+"@stdlib/array/to-circular-iterator","@stdlib/array/to-iterator,@stdlib/array/to-strided-iterator"
+"@stdlib/streams/node/from-circular-array","@stdlib/streams/node/from-array,@stdlib/streams/node/from-iterator,@stdlib/streams/node/from-strided-array"
+"@stdlib/utils/circular-buffer","@stdlib/utils/fifo,@stdlib/utils/stack"
+"@stdlib/datasets/cmudict",""
+"@stdlib/complex/cmplx","@stdlib/complex/float64,@stdlib/complex/float32"
+"@stdlib/complex/float32","@stdlib/complex/cmplx,@stdlib/complex/float64"
+"@stdlib/constants/math/complex64-num-bytes","@stdlib/constants/math/complex128-num-bytes,@stdlib/constants/math/float32-num-bytes"
+"@stdlib/array/complex64","@stdlib/array/complex128,@stdlib/complex/cmplx,@stdlib/complex/float32"
+"@stdlib/complex/float64","@stdlib/complex/cmplx,@stdlib/complex/float32"
+"@stdlib/constants/math/complex128-num-bytes","@stdlib/constants/math/complex64-num-bytes,@stdlib/constants/math/float64-num-bytes"
+"@stdlib/array/complex128","@stdlib/array/complex64,@stdlib/complex/cmplx,@stdlib/complex/float64"
+"@stdlib/utils/compose","@stdlib/utils/async/compose"
+"@stdlib/utils/async/compose","@stdlib/utils/compose"
+"@stdlib/os/configdir","@stdlib/os/homedir,@stdlib/os/tmpdir"
+"@stdlib/complex/conj","@stdlib/complex/imag,@stdlib/complex/real,@stdlib/complex/reim"
+"@stdlib/utils/constant-function","@stdlib/utils/argument-function,@stdlib/utils/identity-function"
+"@stdlib/streams/node/from-constant","@stdlib/streams/node/from-array,@stdlib/streams/node/from-iterator"
+"@stdlib/utils/constructor-name","@stdlib/utils/function-name"
+"@stdlib/assert/contains",""
+"@stdlib/array/convert","@stdlib/array/convert-same"
+"@stdlib/array/convert-same","@stdlib/array/convert"
+"@stdlib/utils/convert-path",""
+"@stdlib/utils/copy","@stdlib/utils/merge"
+"@stdlib/buffer/from-buffer","@stdlib/buffer/alloc-unsafe,@stdlib/buffer/ctor"
+"@stdlib/utils/count-by","@stdlib/utils/group,@stdlib/utils/group-by"
+"@stdlib/utils/async/count-by","@stdlib/utils/count-by,@stdlib/utils/async/group-by,@stdlib/utils/async/tabulate-by"
+"@stdlib/utils/curry","@stdlib/utils/curry-right,@stdlib/utils/uncurry,@stdlib/utils/uncurry-right"
+"@stdlib/utils/curry-right","@stdlib/utils/curry,@stdlib/utils/uncurry,@stdlib/utils/uncurry-right"
+"@stdlib/process/cwd","@stdlib/process/chdir"
+"@stdlib/datasets/dale-chall-new",""
+"@stdlib/datasets",""
+"@stdlib/time/day-of-quarter","@stdlib/time/day-of-year"
+"@stdlib/time/day-of-year","@stdlib/time/day-of-quarter"
+"@stdlib/time/days-in-month","@stdlib/time/days-in-year"
+"@stdlib/time/days-in-year","@stdlib/time/days-in-month"
+"@stdlib/streams/node/debug-sink","@stdlib/streams/node/debug,@stdlib/streams/node/inspect-sink"
+"@stdlib/streams/node/debug","@stdlib/streams/node/debug-sink,@stdlib/streams/node/inspect"
+"@stdlib/assert/deep-equal","@stdlib/assert/is-strict-equal,@stdlib/assert/is-same-value"
+"@stdlib/utils/deep-get","@stdlib/utils/deep-pluck,@stdlib/utils/deep-set"
+"@stdlib/assert/deep-has-own-property","@stdlib/assert/deep-has-property,@stdlib/assert/has-own-property,@stdlib/utils/deep-get,@stdlib/utils/deep-pluck,@stdlib/utils/deep-set"
+"@stdlib/assert/deep-has-property","@stdlib/assert/deep-has-own-property,@stdlib/assert/has-own-property,@stdlib/utils/deep-get,@stdlib/utils/deep-pluck,@stdlib/utils/deep-set"
+"@stdlib/utils/deep-pluck","@stdlib/utils/deep-get,@stdlib/utils/deep-set"
+"@stdlib/utils/deep-set","@stdlib/utils/deep-get,@stdlib/utils/deep-pluck"
+"@stdlib/utils/define-memoized-property","@stdlib/utils/define-memoized-read-only-property,@stdlib/utils/define-property"
+"@stdlib/utils/define-properties","@stdlib/utils/define-property,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/define-property","@stdlib/utils/define-properties,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/dirname","@stdlib/utils/extname"
+"@stdlib/utils/doubly-linked-list","@stdlib/utils/linked-list,@stdlib/utils/stack"
+"@stdlib/utils/do-until","@stdlib/utils/async/do-until,@stdlib/utils/do-until-each,@stdlib/utils/do-while,@stdlib/utils/until,@stdlib/utils/while"
+"@stdlib/utils/async/do-until","@stdlib/utils/do-until,@stdlib/utils/async/do-while,@stdlib/utils/async/until,@stdlib/utils/async/while"
+"@stdlib/utils/do-until-each","@stdlib/utils/do-until-each-right,@stdlib/utils/do-while-each,@stdlib/utils/until-each"
+"@stdlib/utils/do-until-each-right","@stdlib/utils/do-until-each,@stdlib/utils/do-while-each-right,@stdlib/utils/until-each-right"
+"@stdlib/utils/do-while","@stdlib/utils/do-until,@stdlib/utils/async/do-while,@stdlib/utils/do-while-each,@stdlib/utils/until,@stdlib/utils/while"
+"@stdlib/utils/async/do-while","@stdlib/utils/async/do-until,@stdlib/utils/do-while,@stdlib/utils/async/until,@stdlib/utils/async/while"
+"@stdlib/utils/do-while-each","@stdlib/utils/do-until-each,@stdlib/utils/do-while-each-right,@stdlib/utils/while-each"
+"@stdlib/utils/do-while-each-right","@stdlib/utils/do-until-each-right,@stdlib/utils/do-while-each,@stdlib/utils/while-each-right"
+"@stdlib/constants/math/float64-e",""
+"@stdlib/streams/node/empty","@stdlib/streams/node/from-constant"
+"@stdlib/string/ends-with","@stdlib/string/starts-with"
+"@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-properties-in,@stdlib/utils/enumerable-property-symbols,@stdlib/utils/inherited-enumerable-properties,@stdlib/utils/keys,@stdlib/utils/nonenumerable-properties,@stdlib/utils/properties"
+"@stdlib/utils/enumerable-properties-in","@stdlib/utils/enumerable-properties,@stdlib/utils/enumerable-property-symbols-in,@stdlib/utils/inherited-enumerable-properties,@stdlib/utils/keys-in,@stdlib/utils/nonenumerable-properties-in,@stdlib/utils/properties-in"
+"@stdlib/utils/enumerable-property-symbols","@stdlib/utils/enumerable-property-symbols-in,@stdlib/utils/inherited-enumerable-property-symbols,@stdlib/utils/keys,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/property-symbols"
+"@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/enumerable-property-symbols,@stdlib/utils/inherited-enumerable-property-symbols,@stdlib/utils/keys-in,@stdlib/utils/nonenumerable-property-symbols-in,@stdlib/utils/property-symbols-in"
+"@stdlib/process/env","@stdlib/process/argv"
+"@stdlib/constants/math/float64-eps","@stdlib/constants/math/float32-eps"
+"@stdlib/error/to-json","@stdlib/error/reviver"
+"@stdlib/constants/math/float64-eulergamma",""
+"@stdlib/utils/every","@stdlib/utils/any,@stdlib/utils/every-by,@stdlib/utils/for-each,@stdlib/utils/none,@stdlib/utils/some"
+"@stdlib/utils/every-by","@stdlib/utils/any-by,@stdlib/utils/every-by-right,@stdlib/utils/for-each,@stdlib/utils/none-by,@stdlib/utils/some-by"
+"@stdlib/utils/async/every-by","@stdlib/utils/async/any-by,@stdlib/utils/every-by,@stdlib/utils/async/every-by-right,@stdlib/utils/async/for-each,@stdlib/utils/async/none-by,@stdlib/utils/async/some-by"
+"@stdlib/utils/every-by-right","@stdlib/utils/any-by,@stdlib/utils/every,@stdlib/utils/every-by,@stdlib/utils/for-each-right,@stdlib/utils/none-by-right,@stdlib/utils/some-by-right"
+"@stdlib/utils/async/every-by-right","@stdlib/utils/async/any-by-right,@stdlib/utils/async/every-by,@stdlib/utils/every-by-right,@stdlib/utils/async/for-each-right,@stdlib/utils/async/none-by-right,@stdlib/utils/async/some-by-right"
+"@stdlib/utils/eval",""
+"@stdlib/fs/exists","@stdlib/fs/read-file,@stdlib/fs/read-dir"
+"@stdlib/nlp/expand-contractions",""
+"@stdlib/utils/extname","@stdlib/utils/dirname"
+"@stdlib/fastmath/special/abs","@stdlib/math/base/special/abs"
+"@stdlib/fastmath/special/acosh","@stdlib/math/base/special/acosh"
+"@stdlib/fastmath/special/alpha-max-plus-beta-min","@stdlib/math/base/special/hypot"
+"@stdlib/fastmath/special/asinh","@stdlib/math/base/special/asinh"
+"@stdlib/fastmath/special/atanh","@stdlib/math/base/special/atanh"
+"@stdlib/fastmath/special/hypot","@stdlib/math/base/special/hypot"
+"@stdlib/fastmath/special/uint32-log2","@stdlib/math/base/special/log2"
+"@stdlib/fastmath/special/max","@stdlib/math/base/special/max"
+"@stdlib/fastmath/special/min","@stdlib/math/base/special/min"
+"@stdlib/fastmath/special/pow-int","@stdlib/math/base/special/pow"
+"@stdlib/fastmath/special/uint32-sqrt","@stdlib/math/base/special/sqrt"
+"@stdlib/datasets/female-first-names-en","@stdlib/datasets/male-first-names-en"
+"@stdlib/utils/fifo","@stdlib/utils/stack"
+"@stdlib/utils/find",""
+"@stdlib/utils/flatten-array","@stdlib/utils/flatten-object"
+"@stdlib/utils/flatten-object","@stdlib/utils/flatten-array"
+"@stdlib/stats/fligner-test","@stdlib/stats/bartlett-test"
+"@stdlib/constants/math/float16-cbrt-eps","@stdlib/constants/math/float16-eps,@stdlib/constants/math/float16-sqrt-eps,@stdlib/constants/math/float32-cbrt-eps,@stdlib/constants/math/float64-cbrt-eps"
+"@stdlib/constants/math/float16-eps","@stdlib/constants/math/float32-eps,@stdlib/constants/math/float64-eps"
+"@stdlib/constants/math/float16-exponent-bias","@stdlib/constants/math/float32-exponent-bias,@stdlib/constants/math/float64-exponent-bias"
+"@stdlib/constants/math/float16-max","@stdlib/constants/math/float32-max,@stdlib/constants/math/float64-max"
+"@stdlib/constants/math/float16-max-safe-integer","@stdlib/constants/math/float16-min-safe-integer,@stdlib/constants/math/float32-max-safe-integer,@stdlib/constants/math/float64-max-safe-integer"
+"@stdlib/constants/math/float16-min-safe-integer","@stdlib/constants/math/float16-max-safe-integer,@stdlib/constants/math/float32-min-safe-integer,@stdlib/constants/math/float64-min-safe-integer"
+"@stdlib/constants/math/float16-ninf","@stdlib/constants/math/float16-pinf,@stdlib/constants/math/float32-ninf,@stdlib/constants/math/float64-ninf"
+"@stdlib/constants/math/float16-num-bytes","@stdlib/constants/math/float32-num-bytes,@stdlib/constants/math/float64-num-bytes"
+"@stdlib/constants/math/float16-pinf","@stdlib/constants/math/float16-ninf,@stdlib/constants/math/float32-pinf,@stdlib/constants/math/float64-pinf"
+"@stdlib/constants/math/float16-precision","@stdlib/constants/math/float32-precision,@stdlib/constants/math/float64-precision"
+"@stdlib/constants/math/float16-smallest-normal","@stdlib/constants/math/float16-smallest-subnormal,@stdlib/constants/math/float32-smallest-normal,@stdlib/constants/math/float64-smallest-normal"
+"@stdlib/constants/math/float16-smallest-subnormal","@stdlib/constants/math/float16-smallest-normal,@stdlib/constants/math/float32-smallest-subnormal,@stdlib/constants/math/float64-smallest-subnormal"
+"@stdlib/constants/math/float16-sqrt-eps","@stdlib/constants/math/float16-eps,@stdlib/constants/math/float32-sqrt-eps,@stdlib/constants/math/float64-sqrt-eps"
+"@stdlib/constants/math/float32-cbrt-eps","@stdlib/constants/math/float32-eps,@stdlib/constants/math/float32-sqrt-eps,@stdlib/constants/math/float64-cbrt-eps"
+"@stdlib/constants/math/float32-eps","@stdlib/constants/math/float64-eps"
+"@stdlib/constants/math/float32-exponent-bias","@stdlib/constants/math/float16-exponent-bias,@stdlib/constants/math/float64-exponent-bias"
+"@stdlib/constants/math/float32-max","@stdlib/constants/math/float16-max,@stdlib/constants/math/float64-max"
+"@stdlib/constants/math/float32-max-safe-integer","@stdlib/constants/math/float16-max-safe-integer,@stdlib/constants/math/float32-min-safe-integer,@stdlib/constants/math/float64-max-safe-integer"
+"@stdlib/constants/math/float32-min-safe-integer","@stdlib/constants/math/float16-min-safe-integer,@stdlib/constants/math/float32-max-safe-integer,@stdlib/constants/math/float64-min-safe-integer"
+"@stdlib/constants/math/float32-ninf","@stdlib/constants/math/float32-pinf,@stdlib/constants/math/float64-ninf"
+"@stdlib/constants/math/float32-num-bytes","@stdlib/constants/math/float16-num-bytes,@stdlib/constants/math/float64-num-bytes"
+"@stdlib/constants/math/float32-pinf","@stdlib/constants/math/float32-ninf,@stdlib/constants/math/float64-pinf"
+"@stdlib/constants/math/float32-precision","@stdlib/constants/math/float16-precision,@stdlib/constants/math/float64-precision"
+"@stdlib/constants/math/float32-smallest-normal","@stdlib/constants/math/float32-smallest-subnormal,@stdlib/constants/math/float64-smallest-normal"
+"@stdlib/constants/math/float32-smallest-subnormal","@stdlib/constants/math/float32-smallest-normal,@stdlib/constants/math/float64-smallest-subnormal"
+"@stdlib/constants/math/float32-sqrt-eps","@stdlib/constants/math/float32-eps,@stdlib/constants/math/float64-sqrt-eps"
+"@stdlib/array/float32","@stdlib/array/buffer,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/constants/math/float64-exponent-bias","@stdlib/constants/math/float16-exponent-bias,@stdlib/constants/math/float32-exponent-bias"
+"@stdlib/constants/math/float64-high-word-exponent-mask","@stdlib/constants/math/float64-high-word-significand-mask"
+"@stdlib/constants/math/float64-high-word-significand-mask","@stdlib/constants/math/float64-high-word-exponent-mask"
+"@stdlib/constants/math/float64-max","@stdlib/constants/math/float16-max,@stdlib/constants/math/float32-max"
+"@stdlib/constants/math/float64-max-base2-exponent","@stdlib/constants/math/float64-max-base10-exponent,@stdlib/constants/math/float64-max-base2-exponent-subnormal,@stdlib/constants/math/float64-min-base2-exponent"
+"@stdlib/constants/math/float64-max-base2-exponent-subnormal","@stdlib/constants/math/float64-max-base10-exponent-subnormal,@stdlib/constants/math/float64-max-base2-exponent,@stdlib/constants/math/float64-min-base2-exponent-subnormal"
+"@stdlib/constants/math/float64-max-base10-exponent","@stdlib/constants/math/float64-max-base10-exponent-subnormal,@stdlib/constants/math/float64-max-base2-exponent,@stdlib/constants/math/float64-min-base10-exponent"
+"@stdlib/constants/math/float64-max-base10-exponent-subnormal","@stdlib/constants/math/float64-max-base10-exponent,@stdlib/constants/math/float64-max-base2-exponent-subnormal,@stdlib/constants/math/float64-min-base10-exponent-subnormal"
+"@stdlib/constants/math/float64-max-ln","@stdlib/constants/math/float64-min-ln"
+"@stdlib/constants/math/float64-max-safe-fibonacci","@stdlib/constants/math/float64-max-safe-nth-fibonacci"
+"@stdlib/constants/math/float64-max-safe-integer","@stdlib/constants/math/float16-max-safe-integer,@stdlib/constants/math/float32-max-safe-integer,@stdlib/constants/math/float64-min-safe-integer"
+"@stdlib/constants/math/float64-max-safe-lucas","@stdlib/constants/math/float64-max-safe-fibonacci,@stdlib/constants/math/float64-max-safe-nth-lucas"
+"@stdlib/constants/math/float64-max-safe-nth-fibonacci","@stdlib/constants/math/float64-max-safe-fibonacci"
+"@stdlib/constants/math/float64-max-safe-nth-lucas","@stdlib/constants/math/float64-max-safe-lucas,@stdlib/constants/math/float64-max-safe-nth-fibonacci"
+"@stdlib/constants/math/float64-min-base2-exponent","@stdlib/constants/math/float64-max-base2-exponent,@stdlib/constants/math/float64-min-base10-exponent,@stdlib/constants/math/float64-min-base2-exponent-subnormal"
+"@stdlib/constants/math/float64-min-base2-exponent-subnormal","@stdlib/constants/math/float64-max-base2-exponent-subnormal,@stdlib/constants/math/float64-min-base10-exponent-subnormal,@stdlib/constants/math/float64-min-base2-exponent"
+"@stdlib/constants/math/float64-min-base10-exponent","@stdlib/constants/math/float64-max-base10-exponent,@stdlib/constants/math/float64-min-base10-exponent-subnormal,@stdlib/constants/math/float64-min-base2-exponent"
+"@stdlib/constants/math/float64-min-base10-exponent-subnormal","@stdlib/constants/math/float64-max-base10-exponent-subnormal,@stdlib/constants/math/float64-min-base10-exponent,@stdlib/constants/math/float64-min-base2-exponent-subnormal"
+"@stdlib/constants/math/float64-min-ln","@stdlib/constants/math/float64-max-ln"
+"@stdlib/constants/math/float64-min-safe-integer","@stdlib/constants/math/float16-min-safe-integer,@stdlib/constants/math/float32-min-safe-integer,@stdlib/constants/math/float64-max-safe-integer"
+"@stdlib/constants/math/float64-num-bytes","@stdlib/constants/math/float16-num-bytes,@stdlib/constants/math/float32-num-bytes"
+"@stdlib/constants/math/float64-precision","@stdlib/constants/math/float16-precision,@stdlib/constants/math/float32-precision"
+"@stdlib/constants/math/float64-smallest-normal","@stdlib/constants/math/float32-smallest-normal,@stdlib/constants/math/float64-smallest-subnormal"
+"@stdlib/constants/math/float64-smallest-subnormal","@stdlib/constants/math/float32-smallest-subnormal,@stdlib/constants/math/float64-smallest-normal"
+"@stdlib/array/float64","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/utils/for-each","@stdlib/utils/async/for-each,@stdlib/utils/for-each-right"
+"@stdlib/utils/async/for-each","@stdlib/utils/for-each,@stdlib/utils/async/for-each-right"
+"@stdlib/utils/for-each-right","@stdlib/utils/for-each,@stdlib/utils/async/for-each-right"
+"@stdlib/utils/async/for-each-right","@stdlib/utils/async/for-each,@stdlib/utils/for-each-right"
+"@stdlib/utils/for-in","@stdlib/utils/for-each,@stdlib/utils/for-own"
+"@stdlib/utils/for-own","@stdlib/utils/for-each,@stdlib/utils/for-in"
+"@stdlib/constants/math/float64-fourth-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/constants/math/float64-fourth-root-eps","@stdlib/constants/math/float64-eps"
+"@stdlib/datasets/frb-sf-wage-rigidity",""
+"@stdlib/string/from-code-point",""
+"@stdlib/utils/function-name","@stdlib/utils/constructor-name"
+"@stdlib/utils/function-sequence","@stdlib/utils/compose,@stdlib/utils/async/function-sequence"
+"@stdlib/utils/async/function-sequence","@stdlib/utils/async/compose,@stdlib/utils/function-sequence"
+"@stdlib/constants/math/float64-gamma-lanczos-g",""
+"@stdlib/process/getegid","@stdlib/process/geteuid,@stdlib/process/getgid,@stdlib/process/getuid"
+"@stdlib/process/geteuid","@stdlib/process/getegid,@stdlib/process/getgid,@stdlib/process/getuid"
+"@stdlib/process/getgid","@stdlib/process/getegid,@stdlib/process/geteuid,@stdlib/process/getuid"
+"@stdlib/utils/global",""
+"@stdlib/utils/get-prototype-of","@stdlib/assert/is-prototype-of"
+"@stdlib/process/getuid","@stdlib/process/getegid,@stdlib/process/geteuid,@stdlib/process/getgid"
+"@stdlib/constants/math/float64-glaisher-kinkelin",""
+"@stdlib/utils/group","@stdlib/utils/bifurcate,@stdlib/utils/count-by,@stdlib/utils/group-by"
+"@stdlib/utils/group-by","@stdlib/utils/bifurcate-by,@stdlib/utils/count-by,@stdlib/utils/group"
+"@stdlib/utils/async/group-by","@stdlib/utils/async/bifurcate-by,@stdlib/utils/async/count-by,@stdlib/utils/group-by"
+"@stdlib/utils/group-in","@stdlib/utils/bifurcate-in,@stdlib/utils/group-by,@stdlib/utils/group-own"
+"@stdlib/utils/group-own","@stdlib/utils/bifurcate-own,@stdlib/utils/group,@stdlib/utils/group-by"
+"@stdlib/constants/math/float64-half-ln-two","@stdlib/constants/math/float64-ln-two"
+"@stdlib/constants/math/float64-half-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected,@stdlib/datasets/pace-boston-house-prices"
+"@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/datasets/harrison-boston-house-prices,@stdlib/datasets/pace-boston-house-prices"
+"@stdlib/assert/has-arraybuffer-support","@stdlib/assert/has-float32array-support,@stdlib/assert/has-float64array-support,@stdlib/assert/has-int16array-support,@stdlib/assert/has-int32array-support,@stdlib/assert/has-int8array-support,@stdlib/assert/has-node-buffer-support,@stdlib/assert/has-sharedarraybuffer-support,@stdlib/assert/has-uint16array-support,@stdlib/assert/has-uint32array-support,@stdlib/assert/has-uint8array-support,@stdlib/assert/has-uint8clampedarray-support"
+"@stdlib/assert/has-async-await-support",""
+"@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert/has-iterator-symbol-support,@stdlib/assert/has-symbol-support"
+"@stdlib/assert/has-class-support",""
+"@stdlib/assert/has-define-properties-support","@stdlib/assert/has-define-property-support"
+"@stdlib/assert/has-define-property-support","@stdlib/assert/has-define-properties-support"
+"@stdlib/assert/has-float32array-support",""
+"@stdlib/assert/has-float64array-support",""
+"@stdlib/assert/has-function-name-support",""
+"@stdlib/assert/has-generator-support",""
+"@stdlib/assert/has-int8array-support",""
+"@stdlib/assert/has-int16array-support",""
+"@stdlib/assert/has-int32array-support",""
+"@stdlib/assert/has-iterator-symbol-support","@stdlib/assert/has-async-iterator-symbol-support,@stdlib/assert/has-symbol-support"
+"@stdlib/assert/has-map-support",""
+"@stdlib/assert/has-node-buffer-support",""
+"@stdlib/assert/has-own-property","@stdlib/assert/has-property"
+"@stdlib/assert/has-property","@stdlib/assert/has-own-property"
+"@stdlib/assert/has-proxy-support",""
+"@stdlib/assert/has-set-support",""
+"@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert/has-arraybuffer-support,@stdlib/assert/has-float32array-support,@stdlib/assert/has-float64array-support,@stdlib/assert/has-int16array-support,@stdlib/assert/has-int32array-support,@stdlib/assert/has-int8array-support,@stdlib/assert/has-node-buffer-support,@stdlib/assert/has-uint16array-support,@stdlib/assert/has-uint32array-support,@stdlib/assert/has-uint8array-support,@stdlib/assert/has-uint8clampedarray-support"
+"@stdlib/assert/has-symbol-support","@stdlib/assert/has-iterator-symbol-support"
+"@stdlib/assert/has-tostringtag-support",""
+"@stdlib/assert/has-uint8array-support",""
+"@stdlib/assert/has-uint8clampedarray-support",""
+"@stdlib/assert/has-uint16array-support",""
+"@stdlib/assert/has-uint32array-support",""
+"@stdlib/assert/has-weakmap-support",""
+"@stdlib/assert/has-weakset-support",""
+"@stdlib/assert/has-wasm-support",""
+"@stdlib/datasets/herndon-venus-semidiameters",""
+"@stdlib/os/homedir","@stdlib/os/configdir,@stdlib/os/tmpdir"
+"@stdlib/constants/time/hours-in-day","@stdlib/constants/time/hours-in-week"
+"@stdlib/constants/time/hours-in-week","@stdlib/constants/time/hours-in-day"
+"@stdlib/time/hours-in-month","@stdlib/time/hours-in-year"
+"@stdlib/time/hours-in-year","@stdlib/time/hours-in-month"
+"@stdlib/net/http-server",""
+"@stdlib/utils/identity-function","@stdlib/utils/constant-function"
+"@stdlib/utils/if-else","@stdlib/utils/async/if-else,@stdlib/utils/if-then"
+"@stdlib/utils/async/if-else","@stdlib/utils/async/if-then,@stdlib/utils/if-else"
+"@stdlib/utils/if-then","@stdlib/utils/async/if-then,@stdlib/utils/if-else"
+"@stdlib/utils/async/if-then","@stdlib/utils/async/if-else,@stdlib/utils/if-then"
+"@stdlib/complex/imag","@stdlib/complex/real,@stdlib/complex/reim"
+"@stdlib/datasets/img-acanthus-mollis","@stdlib/datasets/img-allium-oreophilum"
+"@stdlib/datasets/img-airplane-from-above",""
+"@stdlib/datasets/img-allium-oreophilum","@stdlib/datasets/img-acanthus-mollis"
+"@stdlib/datasets/img-black-canyon",""
+"@stdlib/datasets/img-dust-bowl-home",""
+"@stdlib/datasets/img-french-alpine-landscape",""
+"@stdlib/datasets/img-locomotion-house-cat","@stdlib/datasets/img-locomotion-nude-male"
+"@stdlib/datasets/img-locomotion-nude-male","@stdlib/datasets/img-locomotion-house-cat"
+"@stdlib/datasets/img-march-pastoral",""
+"@stdlib/datasets/img-nagasaki-boats",""
+"@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mapcorr,@stdlib/stats/incr/pcorr,@stdlib/stats/incr/pcorr2"
+"@stdlib/stats/incr/count","@stdlib/stats/incr/mean,@stdlib/stats/incr/sum,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/covariance","@stdlib/stats/incr/mcovariance,@stdlib/stats/incr/pcorr,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/covmat","@stdlib/stats/incr/covariance,@stdlib/stats/incr/pcorrmat"
+"@stdlib/stats/incr/cv","@stdlib/stats/incr/mean,@stdlib/stats/incr/mcv,@stdlib/stats/incr/stdev,@stdlib/stats/incr/vmr"
+"@stdlib/stats/incr/ewmean","@stdlib/stats/incr/ewvariance,@stdlib/stats/incr/mean,@stdlib/stats/incr/mmean,@stdlib/stats/incr/wmean"
+"@stdlib/stats/incr/ewstdev","@stdlib/stats/incr/ewvariance,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/stdev"
+"@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/ewmean,@stdlib/stats/incr/ewstdev,@stdlib/stats/incr/variance,@stdlib/stats/incr/mvariance"
+"@stdlib/stats/incr/gmean","@stdlib/stats/incr/hmean,@stdlib/stats/incr/mean,@stdlib/stats/incr/mgmean,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/grubbs","@stdlib/stats/incr/mgrubbs"
+"@stdlib/stats/incr/hmean","@stdlib/stats/incr/gmean,@stdlib/stats/incr/mean,@stdlib/stats/incr/mhmean,@stdlib/stats/incr/summary"
+"@stdlib/ml/incr/kmeans",""
+"@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean,@stdlib/stats/incr/skewness,@stdlib/stats/incr/stdev,@stdlib/stats/incr/summary,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/maape","@stdlib/stats/incr/mae,@stdlib/stats/incr/mape,@stdlib/stats/incr/mean,@stdlib/stats/incr/mmaape"
+"@stdlib/stats/incr/mae","@stdlib/stats/incr/mape,@stdlib/stats/incr/me,@stdlib/stats/incr/mean,@stdlib/stats/incr/mmae"
+"@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/apcorr,@stdlib/stats/incr/mpcorr,@stdlib/stats/incr/mpcorr2"
+"@stdlib/stats/incr/mape","@stdlib/stats/incr/maape,@stdlib/stats/incr/mae,@stdlib/stats/incr/mean,@stdlib/stats/incr/mmape"
+"@stdlib/stats/incr/max","@stdlib/stats/incr/midrange,@stdlib/stats/incr/min,@stdlib/stats/incr/mmax,@stdlib/stats/incr/range,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/maxabs","@stdlib/stats/incr/max,@stdlib/stats/incr/minabs,@stdlib/stats/incr/mmaxabs"
+"@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/covariance,@stdlib/stats/incr/mpcorr,@stdlib/stats/incr/mvariance"
+"@stdlib/stats/incr/mcv","@stdlib/stats/incr/cv,@stdlib/stats/incr/mmean,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/mvmr"
+"@stdlib/stats/incr/mda","@stdlib/stats/incr/mape,@stdlib/stats/incr/mmda"
+"@stdlib/stats/incr/me","@stdlib/stats/incr/mae,@stdlib/stats/incr/mean,@stdlib/stats/incr/mme"
+"@stdlib/stats/incr/mean","@stdlib/stats/incr/midrange,@stdlib/stats/incr/mmean,@stdlib/stats/incr/stdev,@stdlib/stats/incr/sum,@stdlib/stats/incr/summary,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mean,@stdlib/stats/incr/mmeanabs,@stdlib/stats/incr/sumabs"
+"@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/mean,@stdlib/stats/incr/meanabs,@stdlib/stats/incr/mmeanabs2,@stdlib/stats/incr/sumabs2"
+"@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mean,@stdlib/stats/incr/meanvar,@stdlib/stats/incr/mmeanstdev,@stdlib/stats/incr/stdev"
+"@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mean,@stdlib/stats/incr/meanstdev,@stdlib/stats/incr/mmeanvar,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/mgmean","@stdlib/stats/incr/gmean,@stdlib/stats/incr/mhmean,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/mgrubbs","@stdlib/stats/incr/grubbs"
+"@stdlib/stats/incr/mhmean","@stdlib/stats/incr/hmean,@stdlib/stats/incr/mgmean,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/midrange","@stdlib/stats/incr/mean,@stdlib/stats/incr/max,@stdlib/stats/incr/min,@stdlib/stats/incr/range,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/min","@stdlib/stats/incr/max,@stdlib/stats/incr/midrange,@stdlib/stats/incr/mmin,@stdlib/stats/incr/range,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/minabs","@stdlib/stats/incr/maxabs,@stdlib/stats/incr/min,@stdlib/stats/incr/mminabs"
+"@stdlib/stats/incr/minmax","@stdlib/stats/incr/max,@stdlib/stats/incr/min,@stdlib/stats/incr/mminmax,@stdlib/stats/incr/range"
+"@stdlib/stats/incr/minmaxabs","@stdlib/stats/incr/maxabs,@stdlib/stats/incr/minabs,@stdlib/stats/incr/minmax,@stdlib/stats/incr/mminmaxabs"
+"@stdlib/stats/incr/mmaape","@stdlib/stats/incr/maape,@stdlib/stats/incr/mmape,@stdlib/stats/incr/mmpe,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/mmae","@stdlib/stats/incr/mae,@stdlib/stats/incr/mme,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/mmape","@stdlib/stats/incr/mape,@stdlib/stats/incr/mmaape,@stdlib/stats/incr/mmpe,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/mmax","@stdlib/stats/incr/max,@stdlib/stats/incr/mmidrange,@stdlib/stats/incr/mmin,@stdlib/stats/incr/mrange,@stdlib/stats/incr/msummary"
+"@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/maxabs,@stdlib/stats/incr/mmax,@stdlib/stats/incr/mminabs"
+"@stdlib/stats/incr/mmda","@stdlib/stats/incr/mda,@stdlib/stats/incr/mmape"
+"@stdlib/stats/incr/mme","@stdlib/stats/incr/me,@stdlib/stats/incr/mmae,@stdlib/stats/incr/mmean"
+"@stdlib/stats/incr/mmean","@stdlib/stats/incr/mean,@stdlib/stats/incr/msum,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/msummary,@stdlib/stats/incr/mvariance"
+"@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/meanabs,@stdlib/stats/incr/mmean,@stdlib/stats/incr/msumabs"
+"@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/meanabs2,@stdlib/stats/incr/mmeanabs,@stdlib/stats/incr/msumabs2"
+"@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/meanstdev,@stdlib/stats/incr/mmean,@stdlib/stats/incr/mmeanvar,@stdlib/stats/incr/mstdev"
+"@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/meanvar,@stdlib/stats/incr/mmean,@stdlib/stats/incr/mmeanstdev,@stdlib/stats/incr/mvariance"
+"@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mmean,@stdlib/stats/incr/mmax,@stdlib/stats/incr/mmin,@stdlib/stats/incr/mrange"
+"@stdlib/stats/incr/mmin","@stdlib/stats/incr/min,@stdlib/stats/incr/mmax,@stdlib/stats/incr/mmidrange,@stdlib/stats/incr/mrange,@stdlib/stats/incr/msummary"
+"@stdlib/stats/incr/mminabs","@stdlib/stats/incr/minabs,@stdlib/stats/incr/mmaxabs,@stdlib/stats/incr/mmin"
+"@stdlib/stats/incr/mminmax","@stdlib/stats/incr/max,@stdlib/stats/incr/min,@stdlib/stats/incr/mmax,@stdlib/stats/incr/minmax,@stdlib/stats/incr/mmin,@stdlib/stats/incr/mrange"
+"@stdlib/stats/incr/mminmaxabs","@stdlib/stats/incr/minmaxabs,@stdlib/stats/incr/mmax,@stdlib/stats/incr/mmaxabs,@stdlib/stats/incr/mmin,@stdlib/stats/incr/mminabs,@stdlib/stats/incr/mminmax"
+"@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmape,@stdlib/stats/incr/mme,@stdlib/stats/incr/mpe"
+"@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrmse,@stdlib/stats/incr/mrss,@stdlib/stats/incr/mse"
+"@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mcovariance,@stdlib/stats/incr/mpcorrdist,@stdlib/stats/incr/pcorr"
+"@stdlib/stats/incr/mpcorr2","@stdlib/stats/incr/mapcorr,@stdlib/stats/incr/mpcorr,@stdlib/stats/incr/pcorr2"
+"@stdlib/stats/incr/mpcorrdist","@stdlib/stats/incr/mpcorr,@stdlib/stats/incr/pcorrdist"
+"@stdlib/stats/incr/mpe","@stdlib/stats/incr/mape,@stdlib/stats/incr/me,@stdlib/stats/incr/mmpe"
+"@stdlib/stats/incr/mprod","@stdlib/stats/incr/msum,@stdlib/stats/incr/prod"
+"@stdlib/stats/incr/mrange","@stdlib/stats/incr/mmax,@stdlib/stats/incr/mmean,@stdlib/stats/incr/mmin,@stdlib/stats/incr/msummary,@stdlib/stats/incr/range"
+"@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mmse,@stdlib/stats/incr/mrss,@stdlib/stats/incr/rmse"
+"@stdlib/stats/incr/mrss","@stdlib/stats/incr/rss,@stdlib/stats/incr/mmse,@stdlib/stats/incr/mrmse"
+"@stdlib/stats/incr/mse","@stdlib/stats/incr/mmse,@stdlib/stats/incr/rmse,@stdlib/stats/incr/rss"
+"@stdlib/stats/incr/mstdev","@stdlib/stats/incr/mmean,@stdlib/stats/incr/msummary,@stdlib/stats/incr/mvariance,@stdlib/stats/incr/stdev"
+"@stdlib/stats/incr/msum","@stdlib/stats/incr/mmean,@stdlib/stats/incr/msummary,@stdlib/stats/incr/sum"
+"@stdlib/stats/incr/msumabs","@stdlib/stats/incr/mmeanabs,@stdlib/stats/incr/msum,@stdlib/stats/incr/sum,@stdlib/stats/incr/sumabs"
+"@stdlib/stats/incr/msumabs2","@stdlib/stats/incr/mmeanabs2,@stdlib/stats/incr/msumabs,@stdlib/stats/incr/sumabs,@stdlib/stats/incr/sumabs2"
+"@stdlib/stats/incr/msummary","@stdlib/stats/incr/mmean,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/msum,@stdlib/stats/incr/mvariance,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/msumprod","@stdlib/stats/incr/mprod,@stdlib/stats/incr/msum,@stdlib/stats/incr/sumprod"
+"@stdlib/stats/incr/mvariance","@stdlib/stats/incr/mmean,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/msummary,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/mvmr","@stdlib/stats/incr/mmean,@stdlib/stats/incr/mvariance,@stdlib/stats/incr/vmr"
+"@stdlib/stats/incr/pcorr","@stdlib/stats/incr/covariance,@stdlib/stats/incr/mpcorr,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/pcorr2","@stdlib/stats/incr/apcorr,@stdlib/stats/incr/mpcorr2,@stdlib/stats/incr/pcorr"
+"@stdlib/stats/incr/pcorrdist","@stdlib/stats/incr/covariance,@stdlib/stats/incr/pcorr,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/pcorrdistmat","@stdlib/stats/incr/pcorrdist,@stdlib/stats/incr/pcorrmat"
+"@stdlib/stats/incr/pcorrmat","@stdlib/stats/incr/covmat,@stdlib/stats/incr/pcorr,@stdlib/stats/incr/pcorrdistmat"
+"@stdlib/stats/incr/prod","@stdlib/stats/incr/mprod,@stdlib/stats/incr/sum,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/range","@stdlib/stats/incr/max,@stdlib/stats/incr/mean,@stdlib/stats/incr/min,@stdlib/stats/incr/mrange,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/rmse","@stdlib/stats/incr/mrmse,@stdlib/stats/incr/mse,@stdlib/stats/incr/rss"
+"@stdlib/stats/incr/rss","@stdlib/stats/incr/mrss,@stdlib/stats/incr/mse,@stdlib/stats/incr/rmse"
+"@stdlib/stats/incr/skewness","@stdlib/stats/incr/kurtosis,@stdlib/stats/incr/mean,@stdlib/stats/incr/stdev,@stdlib/stats/incr/summary,@stdlib/stats/incr/variance"
+"@stdlib/math/utils/incrspace","@stdlib/math/utils/linspace,@stdlib/math/utils/logspace"
+"@stdlib/stats/incr/stdev","@stdlib/stats/incr/kurtosis,@stdlib/stats/incr/mean,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/skewness,@stdlib/stats/incr/summary,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/sum","@stdlib/stats/incr/count,@stdlib/stats/incr/mean,@stdlib/stats/incr/msum,@stdlib/stats/incr/prod,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/sumabs","@stdlib/stats/incr/meanabs,@stdlib/stats/incr/msumabs,@stdlib/stats/incr/sum"
+"@stdlib/stats/incr/sumabs2","@stdlib/stats/incr/meanabs2,@stdlib/stats/incr/msumabs2,@stdlib/stats/incr/sumabs"
+"@stdlib/stats/incr/summary","@stdlib/stats/incr/count,@stdlib/stats/incr/kurtosis,@stdlib/stats/incr/max,@stdlib/stats/incr/mean,@stdlib/stats/incr/midrange,@stdlib/stats/incr/min,@stdlib/stats/incr/msummary,@stdlib/stats/incr/range,@stdlib/stats/incr/skewness,@stdlib/stats/incr/stdev,@stdlib/stats/incr/sum,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/sumprod","@stdlib/stats/incr/msumprod,@stdlib/stats/incr/prod,@stdlib/stats/incr/sum"
+"@stdlib/stats/incr/variance","@stdlib/stats/incr/kurtosis,@stdlib/stats/incr/mean,@stdlib/stats/incr/mstdev,@stdlib/stats/incr/skewness,@stdlib/stats/incr/stdev,@stdlib/stats/incr/summary"
+"@stdlib/stats/incr/vmr","@stdlib/stats/incr/mean,@stdlib/stats/incr/mvmr,@stdlib/stats/incr/variance"
+"@stdlib/stats/incr/wmean","@stdlib/stats/incr/ewmean,@stdlib/stats/incr/mean,@stdlib/stats/incr/mmean"
+"@stdlib/ndarray/ind2sub","@stdlib/ndarray/array,@stdlib/ndarray/ctor,@stdlib/ndarray/sub2ind"
+"@stdlib/utils/index-of",""
+"@stdlib/utils/inherit",""
+"@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/enumerable-properties,@stdlib/utils/enumerable-properties-in,@stdlib/utils/inherited-enumerable-property-symbols,@stdlib/utils/inherited-keys,@stdlib/utils/inherited-nonenumerable-properties,@stdlib/utils/inherited-properties"
+"@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/enumerable-properties,@stdlib/utils/enumerable-property-symbols,@stdlib/utils/inherited-keys,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/nonenumerable-property-symbols-in,@stdlib/utils/property-symbols"
+"@stdlib/utils/inherited-keys","@stdlib/utils/keys,@stdlib/utils/keys-in,@stdlib/utils/inherited-property-names,@stdlib/utils/inherited-property-symbols"
+"@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-enumerable-properties,@stdlib/utils/inherited-nonenumerable-property-names,@stdlib/utils/inherited-nonenumerable-property-symbols,@stdlib/utils/inherited-keys,@stdlib/utils/nonenumerable-properties,@stdlib/utils/nonenumerable-properties-in,@stdlib/utils/properties"
+"@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-properties,@stdlib/utils/inherited-nonenumerable-property-symbols,@stdlib/utils/keys,@stdlib/utils/nonenumerable-property-names,@stdlib/utils/nonenumerable-property-names-in,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/property-names"
+"@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-nonenumerable-properties,@stdlib/utils/inherited-nonenumerable-property-names,@stdlib/utils/nonenumerable-properties,@stdlib/utils/nonenumerable-property-names,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/nonenumerable-property-symbols-in,@stdlib/utils/property-symbols"
+"@stdlib/utils/inherited-properties","@stdlib/utils/properties,@stdlib/utils/properties-in,@stdlib/utils/inherited-property-names,@stdlib/utils/inherited-property-symbols"
+"@stdlib/utils/inherited-property-descriptor","@stdlib/utils/property-descriptor,@stdlib/utils/property-descriptor-in,@stdlib/utils/inherited-keys,@stdlib/utils/inherited-property-descriptors,@stdlib/utils/inherited-property-names,@stdlib/utils/inherited-property-symbols"
+"@stdlib/utils/inherited-property-descriptors","@stdlib/utils/property-descriptors,@stdlib/utils/property-descriptors-in,@stdlib/utils/inherited-keys,@stdlib/utils/inherited-property-names,@stdlib/utils/inherited-property-symbols"
+"@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-keys,@stdlib/utils/inherited-property-descriptors,@stdlib/utils/inherited-property-symbols,@stdlib/utils/property-names,@stdlib/utils/property-names-in"
+"@stdlib/utils/inherited-property-symbols","@stdlib/utils/inherited-keys,@stdlib/utils/inherited-property-descriptors,@stdlib/utils/inherited-property-names,@stdlib/utils/property-symbols,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/inherited-writable-properties","@stdlib/utils/inherited-writable-property-names,@stdlib/utils/inherited-writable-property-symbols,@stdlib/utils/writable-properties,@stdlib/utils/writable-properties-in,@stdlib/utils/properties"
+"@stdlib/utils/inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols,@stdlib/utils/writable-property-names,@stdlib/utils/writable-property-names-in,@stdlib/utils/properties"
+"@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/inherited-writable-property-names,@stdlib/utils/writable-property-symbols,@stdlib/utils/writable-property-symbols-in,@stdlib/utils/properties"
+"@stdlib/utils/inmap","@stdlib/utils/for-each,@stdlib/utils/inmap-right"
+"@stdlib/utils/async/inmap","@stdlib/utils/async/for-each,@stdlib/utils/async/inmap-right,@stdlib/utils/inmap"
+"@stdlib/utils/inmap-right","@stdlib/utils/for-each-right,@stdlib/utils/inmap"
+"@stdlib/utils/async/inmap-right","@stdlib/utils/async/for-each-right,@stdlib/utils/async/inmap,@stdlib/utils/inmap-right"
+"@stdlib/streams/node/inspect-sink","@stdlib/streams/node/debug-sink,@stdlib/streams/node/inspect"
+"@stdlib/streams/node/inspect","@stdlib/streams/node/debug"
+"@stdlib/assert/instance-of","@stdlib/assert/is-prototype-of,@stdlib/utils/constructor-name,@stdlib/utils/inherit,@stdlib/utils/type-of"
+"@stdlib/constants/math/int8-max","@stdlib/constants/math/int8-min"
+"@stdlib/constants/math/int8-min","@stdlib/constants/math/int8-max"
+"@stdlib/constants/math/int8-num-bytes","@stdlib/constants/math/int16-num-bytes,@stdlib/constants/math/int32-num-bytes,@stdlib/constants/math/uint8-num-bytes"
+"@stdlib/array/int8","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/constants/math/int16-max","@stdlib/constants/math/int16-min"
+"@stdlib/constants/math/int16-min","@stdlib/constants/math/int16-max"
+"@stdlib/constants/math/int16-num-bytes","@stdlib/constants/math/int32-num-bytes,@stdlib/constants/math/int8-num-bytes,@stdlib/constants/math/uint16-num-bytes"
+"@stdlib/array/int16","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/constants/math/int32-max","@stdlib/constants/math/int32-min"
+"@stdlib/constants/math/int32-min","@stdlib/constants/math/int32-max"
+"@stdlib/constants/math/int32-num-bytes","@stdlib/constants/math/int16-num-bytes,@stdlib/constants/math/int8-num-bytes,@stdlib/constants/math/uint32-num-bytes"
+"@stdlib/array/int32","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/assert/is-big-endian","@stdlib/assert/is-little-endian"
+"@stdlib/assert/is-browser",""
+"@stdlib/assert/is-darwin",""
+"@stdlib/assert/is-electron","@stdlib/assert/is-electron-main,@stdlib/assert/is-electron-renderer"
+"@stdlib/assert/is-electron-main","@stdlib/assert/is-electron,@stdlib/assert/is-electron-renderer"
+"@stdlib/assert/is-electron-renderer","@stdlib/assert/is-electron,@stdlib/assert/is-electron-main"
+"@stdlib/assert/is-little-endian","@stdlib/assert/is-big-endian"
+"@stdlib/assert/is-node",""
+"@stdlib/assert/is-web-worker",""
+"@stdlib/assert/is-windows",""
+"@stdlib/assert/is-absolute-path","@stdlib/assert/is-relative-path"
+"@stdlib/assert/is-accessor-property","@stdlib/assert/has-own-property,@stdlib/assert/is-accessor-property-in,@stdlib/assert/is-data-property"
+"@stdlib/assert/is-accessor-property-in","@stdlib/assert/has-property,@stdlib/assert/is-accessor-property,@stdlib/assert/is-data-property-in"
+"@stdlib/assert/is-alphagram","@stdlib/assert/is-anagram"
+"@stdlib/assert/is-alphanumeric","@stdlib/assert/is-digit-string"
+"@stdlib/assert/is-anagram","@stdlib/assert/is-alphagram"
+"@stdlib/assert/is-arguments",""
+"@stdlib/assert/is-array","@stdlib/assert/is-array-like"
+"@stdlib/assert/is-array-array",""
+"@stdlib/assert/is-arraybuffer","@stdlib/assert/is-sharedarraybuffer,@stdlib/assert/is-typed-array"
+"@stdlib/assert/is-array-length","@stdlib/assert/is-array"
+"@stdlib/assert/is-array-like","@stdlib/assert/is-array,@stdlib/assert/is-array-like-object"
+"@stdlib/assert/is-array-like-object","@stdlib/assert/is-array,@stdlib/assert/is-array-like"
+"@stdlib/assert/is-ascii","@stdlib/assert/is-string"
+"@stdlib/assert/is-between","@stdlib/assert/is-between-array"
+"@stdlib/assert/is-between-array","@stdlib/assert/is-between"
+"@stdlib/assert/is-binary-string","@stdlib/assert/is-string"
+"@stdlib/assert/is-boolean",""
+"@stdlib/assert/is-boolean-array",""
+"@stdlib/assert/is-boxed-primitive","@stdlib/assert/is-primitive"
+"@stdlib/assert/is-buffer",""
+"@stdlib/assert/is-capitalized","@stdlib/assert/is-string"
+"@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-square-matrix,@stdlib/assert/is-symmetric-matrix"
+"@stdlib/assert/is-circular","@stdlib/assert/is-circular-array,@stdlib/assert/is-circular-plain-object"
+"@stdlib/assert/is-circular-array","@stdlib/assert/is-circular,@stdlib/assert/is-circular-plain-object"
+"@stdlib/assert/is-circular-plain-object","@stdlib/assert/is-circular,@stdlib/assert/is-circular-array"
+"@stdlib/assert/is-collection","@stdlib/assert/is-array-like"
+"@stdlib/assert/is-complex","@stdlib/assert/is-complex64,@stdlib/assert/is-complex128"
+"@stdlib/assert/is-complex64","@stdlib/assert/is-complex,@stdlib/assert/is-complex128"
+"@stdlib/assert/is-complex64array","@stdlib/assert/is-complex,@stdlib/assert/is-complex64,@stdlib/assert/is-complex128array,@stdlib/assert/is-complex-typed-array"
+"@stdlib/assert/is-complex128","@stdlib/assert/is-complex,@stdlib/assert/is-complex64"
+"@stdlib/assert/is-complex128array","@stdlib/assert/is-complex,@stdlib/assert/is-complex128,@stdlib/assert/is-complex64array,@stdlib/assert/is-complex-typed-array"
+"@stdlib/assert/is-complex-like","@stdlib/assert/is-complex,@stdlib/assert/is-complex64,@stdlib/assert/is-complex128"
+"@stdlib/assert/is-complex-typed-array","@stdlib/assert/is-complex,@stdlib/assert/is-complex64array,@stdlib/assert/is-complex128array"
+"@stdlib/assert/is-configurable-property","@stdlib/assert/is-configurable-property-in,@stdlib/assert/is-enumerable-property,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-configurable-property,@stdlib/assert/is-enumerable-property-in,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-data-property","@stdlib/assert/has-own-property,@stdlib/assert/is-accessor-property,@stdlib/assert/is-data-property-in"
+"@stdlib/assert/is-data-property-in","@stdlib/assert/has-property,@stdlib/assert/is-accessor-property-in,@stdlib/assert/is-data-property"
+"@stdlib/assert/is-date-object",""
+"@stdlib/assert/is-digit-string","@stdlib/assert/is-hex-string,@stdlib/assert/is-string"
+"@stdlib/assert/is-email-address",""
+"@stdlib/assert/is-empty-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-empty-object","@stdlib/assert/is-object,@stdlib/assert/is-plain-object"
+"@stdlib/assert/is-empty-string","@stdlib/assert/is-string"
+"@stdlib/assert/is-enumerable-property","@stdlib/assert/is-configurable-property,@stdlib/assert/is-enumerable-property-in,@stdlib/assert/is-nonenumerable-property,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-configurable-property-in,@stdlib/assert/is-enumerable-property,@stdlib/assert/is-nonenumerable-property-in,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-error",""
+"@stdlib/assert/is-eval-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-even","@stdlib/assert/is-odd"
+"@stdlib/assert/is-falsy","@stdlib/assert/is-falsy-array,@stdlib/assert/is-truthy"
+"@stdlib/assert/is-falsy-array","@stdlib/assert/is-falsy,@stdlib/assert/is-truthy-array"
+"@stdlib/assert/is-finite","@stdlib/assert/is-finite-array,@stdlib/assert/is-infinite"
+"@stdlib/assert/is-finite-array","@stdlib/assert/is-finite,@stdlib/assert/is-infinite"
+"@stdlib/assert/is-float32array","@stdlib/assert/is-float64array"
+"@stdlib/assert/is-float64array","@stdlib/assert/is-float32array"
+"@stdlib/assert/is-function",""
+"@stdlib/assert/is-function-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-generator-object","@stdlib/assert/has-generator-support,@stdlib/assert/is-generator-object-like"
+"@stdlib/assert/is-generator-object-like","@stdlib/assert/has-generator-support,@stdlib/assert/is-generator-object"
+"@stdlib/assert/is-hex-string","@stdlib/assert/is-string"
+"@stdlib/assert/is-infinite","@stdlib/assert/is-finite"
+"@stdlib/assert/is-inherited-property","@stdlib/assert/has-own-property,@stdlib/assert/has-property"
+"@stdlib/assert/is-int8array","@stdlib/assert/is-int16array,@stdlib/assert/is-int32array"
+"@stdlib/assert/is-int16array","@stdlib/assert/is-int32array,@stdlib/assert/is-int8array"
+"@stdlib/assert/is-int32array","@stdlib/assert/is-int16array,@stdlib/assert/is-int8array"
+"@stdlib/assert/is-integer","@stdlib/assert/is-number"
+"@stdlib/assert/is-integer-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-iterable-like","@stdlib/assert/is-iterator-like"
+"@stdlib/assert/is-iterator-like","@stdlib/assert/is-iterable-like"
+"@stdlib/assert/is-json",""
+"@stdlib/assert/is-leap-year",""
+"@stdlib/assert/is-lowercase","@stdlib/assert/is-string,@stdlib/assert/is-uppercase"
+"@stdlib/assert/is-matrix-like","@stdlib/assert/is-array,@stdlib/assert/is-array-like,@stdlib/assert/is-ndarray-like,@stdlib/assert/is-typed-array-like,@stdlib/assert/is-vector-like"
+"@stdlib/assert/is-method","@stdlib/assert/has-own-property,@stdlib/assert/is-function,@stdlib/assert/is-method-in"
+"@stdlib/assert/is-method-in","@stdlib/assert/has-property,@stdlib/assert/is-function,@stdlib/assert/is-method"
+"@stdlib/assert/is-named-typed-tuple-like","@stdlib/utils/named-typed-tuple"
+"@stdlib/assert/is-nan","@stdlib/assert/is-number"
+"@stdlib/assert/is-nan-array","@stdlib/assert/is-nan"
+"@stdlib/assert/is-native-function","@stdlib/assert/is-function"
+"@stdlib/assert/is-ndarray-like","@stdlib/assert/is-array,@stdlib/assert/is-array-like,@stdlib/assert/is-matrix-like,@stdlib/assert/is-typed-array-like,@stdlib/assert/is-vector-like"
+"@stdlib/assert/is-negative-integer","@stdlib/assert/is-integer"
+"@stdlib/assert/is-negative-integer-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-negative-number","@stdlib/assert/is-number"
+"@stdlib/assert/is-negative-number-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-negative-zero","@stdlib/assert/is-number,@stdlib/assert/is-positive-zero"
+"@stdlib/assert/is-node-builtin",""
+"@stdlib/assert/is-node-duplex-stream-like","@stdlib/assert/is-node-stream-like"
+"@stdlib/assert/is-node-readable-stream-like","@stdlib/assert/is-node-stream-like"
+"@stdlib/assert/is-node-repl",""
+"@stdlib/assert/is-node-stream-like",""
+"@stdlib/assert/is-node-transform-stream-like","@stdlib/assert/is-node-stream-like"
+"@stdlib/assert/is-node-writable-stream-like","@stdlib/assert/is-node-stream-like"
+"@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-configurable-property,@stdlib/assert/is-enumerable-property,@stdlib/assert/is-nonconfigurable-property-in,@stdlib/assert/is-nonenumerable-property,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-configurable-property-in,@stdlib/assert/is-enumerable-property-in,@stdlib/assert/is-nonconfigurable-property,@stdlib/assert/is-nonenumerable-property-in,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-configurable-property,@stdlib/assert/is-enumerable-property,@stdlib/assert/is-nonconfigurable-property,@stdlib/assert/is-nonenumerable-property-in,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-configurable-property-in,@stdlib/assert/is-enumerable-property-in,@stdlib/assert/is-nonconfigurable-property-in,@stdlib/assert/is-nonenumerable-property,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-nonnegative-integer","@stdlib/assert/is-integer"
+"@stdlib/assert/is-nonnegative-integer-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-nonnegative-number","@stdlib/assert/is-number"
+"@stdlib/assert/is-nonnegative-number-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-nonpositive-integer","@stdlib/assert/is-integer"
+"@stdlib/assert/is-nonpositive-integer-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-nonpositive-number","@stdlib/assert/is-number"
+"@stdlib/assert/is-nonpositive-number-array","@stdlib/assert/is-array"
+"@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-square-matrix,@stdlib/assert/is-symmetric-matrix"
+"@stdlib/assert/is-null","@stdlib/assert/is-undefined,@stdlib/assert/is-undefined-or-null"
+"@stdlib/assert/is-null-array","@stdlib/assert/is-array,@stdlib/assert/is-null"
+"@stdlib/assert/is-number",""
+"@stdlib/assert/is-number-array","@stdlib/assert/is-array,@stdlib/assert/is-number,@stdlib/assert/is-numeric-array"
+"@stdlib/assert/is-numeric-array","@stdlib/assert/is-array,@stdlib/assert/is-number-array,@stdlib/assert/is-typed-array"
+"@stdlib/assert/is-object","@stdlib/assert/is-object-like,@stdlib/assert/is-plain-object"
+"@stdlib/assert/is-object-array","@stdlib/assert/is-array,@stdlib/assert/is-object"
+"@stdlib/assert/is-object-like","@stdlib/assert/is-object,@stdlib/assert/is-plain-object"
+"@stdlib/assert/is-odd","@stdlib/assert/is-even"
+"@stdlib/time/iso-weeks-in-year",""
+"@stdlib/assert/is-persymmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-square-matrix,@stdlib/assert/is-symmetric-matrix"
+"@stdlib/assert/is-plain-object","@stdlib/assert/is-object"
+"@stdlib/assert/is-plain-object-array","@stdlib/assert/is-array,@stdlib/assert/is-plain-object"
+"@stdlib/assert/is-positive-integer","@stdlib/assert/is-integer"
+"@stdlib/assert/is-positive-integer-array","@stdlib/assert/is-array,@stdlib/assert/is-integer,@stdlib/assert/is-positive-integer"
+"@stdlib/assert/is-positive-number","@stdlib/assert/is-number"
+"@stdlib/assert/is-positive-number-array","@stdlib/assert/is-array,@stdlib/assert/is-number,@stdlib/assert/is-positive-number"
+"@stdlib/assert/is-positive-zero","@stdlib/assert/is-number,@stdlib/assert/is-negative-zero"
+"@stdlib/assert/is-primitive","@stdlib/assert/is-boxed-primitive"
+"@stdlib/assert/is-primitive-array","@stdlib/assert/is-array,@stdlib/assert/is-primitive"
+"@stdlib/assert/is-prng-like",""
+"@stdlib/assert/is-probability","@stdlib/assert/is-number"
+"@stdlib/assert/is-probability-array","@stdlib/assert/is-array,@stdlib/assert/is-probability"
+"@stdlib/assert/is-prototype-of","@stdlib/utils/get-prototype-of"
+"@stdlib/assert/is-range-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-readable-property","@stdlib/assert/is-read-only-property,@stdlib/assert/is-read-write-property,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-readable-property-in","@stdlib/assert/is-read-only-property-in,@stdlib/assert/is-read-write-property-in,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-only-property-in,@stdlib/assert/is-read-write-property,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-only-property,@stdlib/assert/is-read-write-property-in,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-read-write-property","@stdlib/assert/is-read-only-property,@stdlib/assert/is-read-write-property-in,@stdlib/assert/is-readable-property,@stdlib/assert/is-writable-property"
+"@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-read-only-property-in,@stdlib/assert/is-read-write-property,@stdlib/assert/is-readable-property-in,@stdlib/assert/is-writable-property-in"
+"@stdlib/assert/is-reference-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-regexp",""
+"@stdlib/assert/is-regexp-string","@stdlib/assert/is-regexp"
+"@stdlib/assert/is-relative-path","@stdlib/assert/is-absolute-path"
+"@stdlib/assert/is-safe-integer","@stdlib/assert/is-integer,@stdlib/assert/is-number"
+"@stdlib/assert/is-safe-integer-array","@stdlib/assert/is-array,@stdlib/assert/is-safe-integer"
+"@stdlib/assert/is-same-value","@stdlib/assert/is-same-value-zero,@stdlib/assert/is-strict-equal"
+"@stdlib/assert/is-same-value-zero","@stdlib/assert/is-same-value,@stdlib/assert/is-strict-equal"
+"@stdlib/assert/is-sharedarraybuffer","@stdlib/assert/is-arraybuffer,@stdlib/assert/is-typed-array"
+"@stdlib/assert/is-skew-centrosymmetric-matrix","@stdlib/assert/is-centrosymmetric-matrix,@stdlib/assert/is-matrix-like,@stdlib/assert/is-skew-symmetric-matrix"
+"@stdlib/assert/is-skew-persymmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-persymmetric-matrix,@stdlib/assert/is-skew-symmetric-matrix"
+"@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-skew-symmetric-matrix,@stdlib/assert/is-square-matrix"
+"@stdlib/assert/is-square-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-symmetric-matrix"
+"@stdlib/assert/is-strict-equal","@stdlib/assert/is-same-value"
+"@stdlib/assert/is-string",""
+"@stdlib/assert/is-string-array","@stdlib/assert/is-array,@stdlib/assert/is-string"
+"@stdlib/assert/is-symbol",""
+"@stdlib/assert/is-symbol-array","@stdlib/assert/is-array,@stdlib/assert/is-symbol"
+"@stdlib/assert/is-symmetric-matrix","@stdlib/assert/is-matrix-like,@stdlib/assert/is-nonsymmetric-matrix,@stdlib/assert/is-square-matrix"
+"@stdlib/assert/is-syntax-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-truthy","@stdlib/assert/is-falsy"
+"@stdlib/assert/is-truthy-array","@stdlib/assert/is-falsy-array,@stdlib/assert/is-truthy"
+"@stdlib/assert/is-typed-array","@stdlib/assert/is-array,@stdlib/assert/is-typed-array-like"
+"@stdlib/assert/is-typed-array-length","@stdlib/assert/is-array-length,@stdlib/assert/is-typed-array"
+"@stdlib/assert/is-typed-array-like","@stdlib/assert/is-typed-array"
+"@stdlib/assert/is-type-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-uint8array","@stdlib/assert/is-typed-array,@stdlib/assert/is-uint16array,@stdlib/assert/is-uint32array"
+"@stdlib/assert/is-uint8clampedarray","@stdlib/assert/is-typed-array,@stdlib/assert/is-uint8array"
+"@stdlib/assert/is-uint16array","@stdlib/assert/is-typed-array,@stdlib/assert/is-uint32array,@stdlib/assert/is-uint8array"
+"@stdlib/assert/is-uint32array","@stdlib/assert/is-typed-array,@stdlib/assert/is-uint16array,@stdlib/assert/is-uint8array"
+"@stdlib/assert/is-unc-path",""
+"@stdlib/assert/is-undefined","@stdlib/assert/is-null,@stdlib/assert/is-undefined-or-null"
+"@stdlib/assert/is-undefined-or-null","@stdlib/assert/is-null,@stdlib/assert/is-undefined"
+"@stdlib/assert/is-unity-probability-array","@stdlib/assert/is-probability,@stdlib/assert/is-probability-array"
+"@stdlib/assert/is-uppercase","@stdlib/assert/is-lowercase,@stdlib/assert/is-string"
+"@stdlib/assert/is-uri",""
+"@stdlib/assert/is-uri-error","@stdlib/assert/is-error"
+"@stdlib/assert/is-vector-like","@stdlib/assert/is-array,@stdlib/assert/is-array-like,@stdlib/assert/is-matrix-like,@stdlib/assert/is-ndarray-like,@stdlib/assert/is-typed-array-like"
+"@stdlib/assert/is-whitespace","@stdlib/regexp/whitespace"
+"@stdlib/assert/is-writable-property","@stdlib/assert/is-readable-property,@stdlib/assert/is-read-write-property,@stdlib/assert/is-writable-property-in,@stdlib/assert/is-write-only-property"
+"@stdlib/assert/is-writable-property-in","@stdlib/assert/is-readable-property-in,@stdlib/assert/is-read-write-property-in,@stdlib/assert/is-writable-property,@stdlib/assert/is-write-only-property-in"
+"@stdlib/assert/is-write-only-property","@stdlib/assert/is-read-only-property,@stdlib/assert/is-read-write-property,@stdlib/assert/is-writable-property,@stdlib/assert/is-write-only-property-in"
+"@stdlib/assert/is-write-only-property-in","@stdlib/assert/is-read-only-property-in,@stdlib/assert/is-read-write-property-in,@stdlib/assert/is-writable-property-in,@stdlib/assert/is-write-only-property"
+"@stdlib/math/iter/add","@stdlib/math/iter/divide,@stdlib/math/iter/multiply,@stdlib/math/iter/subtract"
+"@stdlib/iter/advance","@stdlib/iter/head,@stdlib/iter/slice"
+"@stdlib/iter/any","@stdlib/iter/any-by,@stdlib/iter/every,@stdlib/iter/for-each,@stdlib/iter/none,@stdlib/iter/some"
+"@stdlib/iter/any-by","@stdlib/iter/any,@stdlib/iter/every-by,@stdlib/iter/for-each,@stdlib/iter/none-by,@stdlib/iter/some-by"
+"@stdlib/array/from-iterator","@stdlib/array/to-iterator,@stdlib/iter/to-array-view"
+"@stdlib/iter/to-array-view","@stdlib/array/from-iterator,@stdlib/array/to-view-iterator,@stdlib/iter/to-array-view-right"
+"@stdlib/iter/to-array-view-right","@stdlib/array/from-iterator,@stdlib/array/to-view-iterator-right,@stdlib/iter/to-array-view"
+"@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-array"
+"@stdlib/symbol/iterator","@stdlib/symbol/ctor"
+"@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awln,@stdlib/simulate/iter/awun"
+"@stdlib/simulate/iter/awln","@stdlib/simulate/iter/awgn,@stdlib/simulate/iter/awun"
+"@stdlib/simulate/iter/awun","@stdlib/simulate/iter/awgn,@stdlib/simulate/iter/awln"
+"@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/bartlett-pulse,@stdlib/simulate/iter/hann-pulse,@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/simulate/iter/bartlett-pulse","@stdlib/simulate/iter/bartlett-hann-pulse,@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/iter/concat",""
+"@stdlib/iter/constant","@stdlib/utils/constant-function"
+"@stdlib/simulate/iter/cosine-wave","@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sawtooth-wave,@stdlib/simulate/iter/sine-wave,@stdlib/simulate/iter/square-wave,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/iter/counter","@stdlib/iter/length"
+"@stdlib/stats/iter/cugmean","@stdlib/stats/iter/cuhmean,@stdlib/stats/iter/cumean"
+"@stdlib/stats/iter/cuhmean","@stdlib/stats/iter/cugmean,@stdlib/stats/iter/cumean"
+"@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumidrange,@stdlib/stats/iter/cumin,@stdlib/stats/iter/curange,@stdlib/stats/iter/max"
+"@stdlib/stats/iter/cumaxabs","@stdlib/stats/iter/cumax,@stdlib/stats/iter/cuminabs,@stdlib/stats/iter/maxabs"
+"@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumidrange,@stdlib/stats/iter/cusum,@stdlib/stats/iter/mean"
+"@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cumean,@stdlib/stats/iter/cumeanabs2,@stdlib/stats/iter/cusumabs,@stdlib/stats/iter/meanabs"
+"@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cumean,@stdlib/stats/iter/cumeanabs,@stdlib/stats/iter/cusumabs2,@stdlib/stats/iter/meanabs2"
+"@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cumean,@stdlib/stats/iter/cumax,@stdlib/stats/iter/cumin,@stdlib/stats/iter/curange,@stdlib/stats/iter/midrange"
+"@stdlib/stats/iter/cumin","@stdlib/stats/iter/cumax,@stdlib/stats/iter/cumidrange,@stdlib/stats/iter/curange,@stdlib/stats/iter/min"
+"@stdlib/stats/iter/cuminabs","@stdlib/stats/iter/cumaxabs,@stdlib/stats/iter/cumin,@stdlib/stats/iter/minabs"
+"@stdlib/stats/iter/cuprod","@stdlib/stats/iter/cusum,@stdlib/stats/iter/prod"
+"@stdlib/stats/iter/curange","@stdlib/stats/iter/cumax,@stdlib/stats/iter/cumean,@stdlib/stats/iter/cumin,@stdlib/stats/iter/range"
+"@stdlib/stats/iter/cusum","@stdlib/stats/iter/cumean,@stdlib/stats/iter/sum,@stdlib/stats/iter/cuprod"
+"@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/cumeanabs,@stdlib/stats/iter/cusum,@stdlib/stats/iter/sumabs"
+"@stdlib/stats/iter/cusumabs2","@stdlib/stats/iter/cumeanabs2,@stdlib/stats/iter/cusumabs,@stdlib/stats/iter/sumabs2"
+"@stdlib/iter/dedupe","@stdlib/iter/dedupe-by,@stdlib/iter/unique"
+"@stdlib/iter/dedupe-by","@stdlib/iter/dedupe,@stdlib/iter/unique"
+"@stdlib/simulate/iter/dirac-comb","@stdlib/simulate/iter/pulse"
+"@stdlib/math/iter/divide","@stdlib/math/iter/add,@stdlib/math/iter/divide,@stdlib/math/iter/multiply"
+"@stdlib/iter/empty","@stdlib/iter/constant"
+"@stdlib/iter/every","@stdlib/iter/any,@stdlib/iter/every-by,@stdlib/iter/for-each,@stdlib/iter/none,@stdlib/iter/some"
+"@stdlib/iter/every-by","@stdlib/iter/any-by,@stdlib/iter/every,@stdlib/iter/for-each,@stdlib/iter/none-by,@stdlib/iter/some-by"
+"@stdlib/math/iter/fibonacci","@stdlib/math/base/special/fibonacci,@stdlib/math/iter/nonfibonacci"
+"@stdlib/iter/fill",""
+"@stdlib/iter/filter","@stdlib/iter/filter-map,@stdlib/iter/map,@stdlib/iter/reject"
+"@stdlib/iter/filter-map","@stdlib/iter/filter,@stdlib/iter/map"
+"@stdlib/iter/first","@stdlib/iter/head,@stdlib/iter/last,@stdlib/iter/nth"
+"@stdlib/simulate/iter/flat-top-pulse","@stdlib/simulate/iter/pulse"
+"@stdlib/iter/flow","@stdlib/iter/pipeline"
+"@stdlib/iter/for-each","@stdlib/iter/map"
+"@stdlib/simulate/iter/hann-pulse","@stdlib/simulate/iter/bartlett-hann-pulse,@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sine-wave"
+"@stdlib/iter/head","@stdlib/iter/first,@stdlib/iter/slice"
+"@stdlib/iter/intersection","@stdlib/iter/intersection-by-hash,@stdlib/iter/union,@stdlib/iter/unique"
+"@stdlib/iter/intersection-by-hash","@stdlib/iter/intersection,@stdlib/iter/unique-by-hash"
+"@stdlib/simulate/iter/lanczos-pulse","@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/periodic-sinc"
+"@stdlib/iter/last","@stdlib/iter/first,@stdlib/iter/nth"
+"@stdlib/iter/length","@stdlib/iter/counter"
+"@stdlib/iter/map","@stdlib/iter/filter,@stdlib/iter/filter-map,@stdlib/iter/for-each,@stdlib/iter/reject"
+"@stdlib/iter/mapn","@stdlib/iter/map"
+"@stdlib/stats/iter/max","@stdlib/stats/iter/midrange,@stdlib/stats/iter/min,@stdlib/stats/iter/mmax,@stdlib/stats/iter/range"
+"@stdlib/stats/iter/maxabs","@stdlib/stats/iter/max,@stdlib/stats/iter/minabs,@stdlib/stats/iter/mmaxabs"
+"@stdlib/stats/iter/mean","@stdlib/stats/iter/midrange,@stdlib/stats/iter/mmean,@stdlib/stats/iter/stdev,@stdlib/stats/iter/sum,@stdlib/stats/iter/variance"
+"@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mean,@stdlib/stats/iter/mmeanabs,@stdlib/stats/iter/sumabs"
+"@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/mean,@stdlib/stats/iter/meanabs,@stdlib/stats/iter/mmeanabs2,@stdlib/stats/iter/sumabs2"
+"@stdlib/stats/iter/midrange","@stdlib/stats/iter/mean,@stdlib/stats/iter/max,@stdlib/stats/iter/min,@stdlib/stats/iter/range"
+"@stdlib/stats/iter/min","@stdlib/stats/iter/max,@stdlib/stats/iter/midrange,@stdlib/stats/iter/mmin,@stdlib/stats/iter/range"
+"@stdlib/stats/iter/minabs","@stdlib/stats/iter/maxabs,@stdlib/stats/iter/min,@stdlib/stats/iter/mminabs"
+"@stdlib/stats/iter/mmax","@stdlib/stats/iter/max,@stdlib/stats/iter/mmidrange,@stdlib/stats/iter/mmin,@stdlib/stats/iter/mrange"
+"@stdlib/stats/iter/mmaxabs","@stdlib/stats/iter/maxabs,@stdlib/stats/iter/mmax,@stdlib/stats/iter/mminabs"
+"@stdlib/stats/iter/mmean","@stdlib/stats/iter/mean,@stdlib/stats/iter/msum"
+"@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/meanabs,@stdlib/stats/iter/mmean,@stdlib/stats/iter/msumabs"
+"@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/meanabs2,@stdlib/stats/iter/mmeanabs,@stdlib/stats/iter/msumabs2"
+"@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/midrange,@stdlib/stats/iter/mmean,@stdlib/stats/iter/mmax,@stdlib/stats/iter/mmin,@stdlib/stats/iter/mrange"
+"@stdlib/stats/iter/mmin","@stdlib/stats/iter/min,@stdlib/stats/iter/mmax,@stdlib/stats/iter/mmidrange,@stdlib/stats/iter/mrange"
+"@stdlib/stats/iter/mminabs","@stdlib/stats/iter/minabs,@stdlib/stats/iter/mmaxabs,@stdlib/stats/iter/mmin"
+"@stdlib/math/iter/mod","@stdlib/math/iter/divide"
+"@stdlib/stats/iter/mprod","@stdlib/stats/iter/msum,@stdlib/stats/iter/prod"
+"@stdlib/stats/iter/mrange","@stdlib/stats/iter/mmax,@stdlib/stats/iter/mmean,@stdlib/stats/iter/mmin,@stdlib/stats/iter/range"
+"@stdlib/stats/iter/msum","@stdlib/stats/iter/mmean,@stdlib/stats/iter/sum"
+"@stdlib/stats/iter/msumabs","@stdlib/stats/iter/mmeanabs,@stdlib/stats/iter/msum,@stdlib/stats/iter/sum,@stdlib/stats/iter/sumabs"
+"@stdlib/stats/iter/msumabs2","@stdlib/stats/iter/mmeanabs2,@stdlib/stats/iter/msumabs,@stdlib/stats/iter/sumabs,@stdlib/stats/iter/sumabs2"
+"@stdlib/math/iter/multiply","@stdlib/math/iter/add,@stdlib/math/iter/divide,@stdlib/math/iter/subtract"
+"@stdlib/iter/none","@stdlib/iter/any,@stdlib/iter/every,@stdlib/iter/for-each,@stdlib/iter/none-by,@stdlib/iter/some"
+"@stdlib/iter/none-by","@stdlib/iter/any-by,@stdlib/iter/every-by,@stdlib/iter/for-each,@stdlib/iter/none,@stdlib/iter/some-by"
+"@stdlib/math/iter/nonfibonacci","@stdlib/math/base/special/nonfibonacci,@stdlib/math/iter/fibonacci"
+"@stdlib/iter/nth","@stdlib/iter/first,@stdlib/iter/last"
+"@stdlib/simulate/iter/periodic-sinc","@stdlib/simulate/iter/sine-wave"
+"@stdlib/iter/pipeline","@stdlib/iter/flow,@stdlib/iter/pipeline-thunk"
+"@stdlib/iter/pop","@stdlib/iter/push,@stdlib/iter/shift,@stdlib/iter/slice"
+"@stdlib/stats/iter/prod","@stdlib/stats/iter/mprod,@stdlib/stats/iter/sum"
+"@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave,@stdlib/simulate/iter/sine-wave,@stdlib/simulate/iter/square-wave,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/iter/push","@stdlib/iter/concat,@stdlib/iter/unshift"
+"@stdlib/stats/iter/range","@stdlib/stats/iter/max,@stdlib/stats/iter/mean,@stdlib/stats/iter/min,@stdlib/stats/iter/mrange"
+"@stdlib/iter/reject","@stdlib/iter/filter,@stdlib/iter/map"
+"@stdlib/iter/replicate","@stdlib/iter/replicate-by"
+"@stdlib/iter/replicate-by","@stdlib/iter/replicate"
+"@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sine-wave,@stdlib/simulate/iter/square-wave,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/iter/shift","@stdlib/iter/pop,@stdlib/iter/slice,@stdlib/iter/unshift"
+"@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/cosine-wave,@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sawtooth-wave,@stdlib/simulate/iter/square-wave,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/iter/slice","@stdlib/iter/first,@stdlib/iter/head"
+"@stdlib/iter/some","@stdlib/iter/any,@stdlib/iter/every,@stdlib/iter/for-each,@stdlib/iter/none,@stdlib/iter/some-by"
+"@stdlib/iter/some-by","@stdlib/iter/any-by,@stdlib/iter/every-by,@stdlib/iter/for-each,@stdlib/iter/none-by,@stdlib/iter/some"
+"@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sawtooth-wave,@stdlib/simulate/iter/sine-wave,@stdlib/simulate/iter/triangle-wave"
+"@stdlib/stats/iter/stdev","@stdlib/stats/iter/mean,@stdlib/stats/iter/variance"
+"@stdlib/math/iter/subtract","@stdlib/math/iter/add,@stdlib/math/iter/divide,@stdlib/math/iter/multiply"
+"@stdlib/stats/iter/sum","@stdlib/stats/iter/mean,@stdlib/stats/iter/msum,@stdlib/stats/iter/prod"
+"@stdlib/stats/iter/sumabs","@stdlib/stats/iter/meanabs,@stdlib/stats/iter/msumabs,@stdlib/stats/iter/sum"
+"@stdlib/stats/iter/sumabs2","@stdlib/stats/iter/meanabs2,@stdlib/stats/iter/msumabs2,@stdlib/stats/iter/sumabs"
+"@stdlib/iter/pipeline-thunk","@stdlib/iter/pipeline"
+"@stdlib/simulate/iter/triangle-wave","@stdlib/simulate/iter/pulse,@stdlib/simulate/iter/sawtooth-wave,@stdlib/simulate/iter/sine-wave,@stdlib/simulate/iter/square-wave"
+"@stdlib/iter/union","@stdlib/iter/intersection,@stdlib/iter/unique"
+"@stdlib/iter/unique","@stdlib/iter/unique-by,@stdlib/iter/unique-by-hash"
+"@stdlib/iter/unique-by","@stdlib/iter/unique,@stdlib/iter/unique-by-hash"
+"@stdlib/iter/unique-by-hash","@stdlib/iter/unique,@stdlib/iter/unique-by"
+"@stdlib/iter/unshift","@stdlib/iter/concat,@stdlib/iter/push,@stdlib/iter/shift"
+"@stdlib/stats/iter/variance","@stdlib/stats/iter/mean,@stdlib/stats/iter/stdev"
+"@stdlib/streams/node/join","@stdlib/streams/node/split"
+"@stdlib/stats/kde2d",""
+"@stdlib/utils/key-by","@stdlib/utils/for-each"
+"@stdlib/utils/key-by-right","@stdlib/utils/for-each-right,@stdlib/utils/key-by"
+"@stdlib/utils/keys-in","@stdlib/utils/entries-in,@stdlib/utils/keys,@stdlib/utils/values-in"
+"@stdlib/stats/kruskal-test",""
+"@stdlib/stats/kstest",""
+"@stdlib/nlp/lda",""
+"@stdlib/utils/linked-list","@stdlib/utils/doubly-linked-list,@stdlib/utils/stack"
+"@stdlib/math/utils/linspace","@stdlib/math/utils/incrspace,@stdlib/math/utils/logspace"
+"@stdlib/datasets/liu-negative-opinion-words-en","@stdlib/datasets/liu-positive-opinion-words-en"
+"@stdlib/datasets/liu-positive-opinion-words-en","@stdlib/datasets/liu-negative-opinion-words-en"
+"@stdlib/constants/math/float64-ln-half",""
+"@stdlib/constants/math/float64-ln-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/constants/math/float64-ln-sqrt-two-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/constants/math/float64-ln-two-pi","@stdlib/constants/math/float64-two-pi"
+"@stdlib/constants/math/float64-ln-two","@stdlib/constants/math/float64-ln-ten"
+"@stdlib/constants/math/float64-ln-ten","@stdlib/constants/math/float64-ln-two"
+"@stdlib/constants/math/float64-log2-e","@stdlib/constants/math/float64-e,@stdlib/constants/math/float64-log10-e"
+"@stdlib/constants/math/float64-log10-e","@stdlib/constants/math/float64-e,@stdlib/constants/math/float64-log2-e"
+"@stdlib/math/utils/logspace","@stdlib/math/utils/incrspace,@stdlib/math/utils/linspace"
+"@stdlib/string/lowercase","@stdlib/string/uncapitalize,@stdlib/string/uppercase"
+"@stdlib/utils/lowercase-keys","@stdlib/utils/uncapitalize-keys,@stdlib/utils/uppercase-keys"
+"@stdlib/stats/lowess",""
+"@stdlib/string/left-pad","@stdlib/string/pad,@stdlib/string/right-pad"
+"@stdlib/string/left-trim","@stdlib/string/trim,@stdlib/string/right-trim"
+"@stdlib/datasets/male-first-names-en","@stdlib/datasets/female-first-names-en"
+"@stdlib/utils/map-function","@stdlib/utils/async/map-function"
+"@stdlib/utils/async/map-function","@stdlib/utils/map-function"
+"@stdlib/utils/map-keys","@stdlib/utils/map-values"
+"@stdlib/utils/async/map-keys","@stdlib/utils/map-keys,@stdlib/utils/async/map-values"
+"@stdlib/utils/map-values","@stdlib/utils/map-keys,@stdlib/utils/omit-by,@stdlib/utils/pick-by"
+"@stdlib/utils/async/map-values","@stdlib/utils/async/map-keys,@stdlib/utils/map-values"
+"@stdlib/constants/array/max-array-length","@stdlib/constants/array/max-typed-array-length"
+"@stdlib/constants/array/max-typed-array-length","@stdlib/constants/array/max-array-length"
+"@stdlib/utils/memoize",""
+"@stdlib/utils/merge","@stdlib/utils/copy"
+"@stdlib/constants/time/milliseconds-in-day",""
+"@stdlib/constants/time/milliseconds-in-hour",""
+"@stdlib/constants/time/milliseconds-in-minute",""
+"@stdlib/constants/time/milliseconds-in-second",""
+"@stdlib/constants/time/milliseconds-in-week",""
+"@stdlib/datasets/minard-napoleons-march",""
+"@stdlib/constants/time/minutes-in-day",""
+"@stdlib/constants/time/minutes-in-hour",""
+"@stdlib/constants/time/minutes-in-week",""
+"@stdlib/time/minutes-in-month","@stdlib/time/minutes-in-year"
+"@stdlib/time/minutes-in-year","@stdlib/time/minutes-in-month"
+"@stdlib/datasets/moby-dick",""
+"@stdlib/datasets/month-names-en",""
+"@stdlib/constants/time/months-in-year",""
+"@stdlib/utils/move-property",""
+"@stdlib/utils/named-typed-tuple","@stdlib/array/typed"
+"@stdlib/utils/native-class","@stdlib/utils/constructor-name,@stdlib/utils/type-of"
+"@stdlib/ndarray/ctor","@stdlib/ndarray/array"
+"@stdlib/ndarray/casting-modes","@stdlib/ndarray/array,@stdlib/ndarray/ctor"
+"@stdlib/ndarray/dtypes","@stdlib/array/dtypes,@stdlib/ndarray/array,@stdlib/ndarray/ctor,@stdlib/array/typed-dtypes"
+"@stdlib/ndarray/index-modes","@stdlib/ndarray/array,@stdlib/ndarray/ctor"
+"@stdlib/ndarray/memoized-ctor","@stdlib/ndarray/array,@stdlib/ndarray/ctor"
+"@stdlib/ndarray/min-dtype","@stdlib/ndarray/dtypes,@stdlib/ndarray/promotion-rules,@stdlib/ndarray/safe-casts"
+"@stdlib/ndarray/next-dtype","@stdlib/ndarray/dtypes,@stdlib/ndarray/promotion-rules,@stdlib/ndarray/safe-casts"
+"@stdlib/ndarray/orders","@stdlib/ndarray/array,@stdlib/ndarray/ctor"
+"@stdlib/ndarray/promotion-rules","@stdlib/ndarray/casting-modes,@stdlib/ndarray/dtypes,@stdlib/ndarray/safe-casts"
+"@stdlib/ndarray/safe-casts","@stdlib/ndarray/casting-modes,@stdlib/ndarray/dtypes,@stdlib/ndarray/same-kind-casts"
+"@stdlib/ndarray/same-kind-casts","@stdlib/ndarray/casting-modes,@stdlib/ndarray/dtypes,@stdlib/ndarray/safe-casts"
+"@stdlib/datasets/nightingales-rose",""
+"@stdlib/constants/math/float64-ninf","@stdlib/constants/math/float16-ninf,@stdlib/constants/math/float32-ninf,@stdlib/constants/math/float64-pinf"
+"@stdlib/process/node-version",""
+"@stdlib/utils/none","@stdlib/utils/any,@stdlib/utils/every,@stdlib/utils/for-each,@stdlib/utils/none-by,@stdlib/utils/some"
+"@stdlib/utils/none-by","@stdlib/utils/any-by,@stdlib/utils/every-by,@stdlib/utils/for-each,@stdlib/utils/none,@stdlib/utils/none-by-right,@stdlib/utils/some-by"
+"@stdlib/utils/async/none-by","@stdlib/utils/async/any-by,@stdlib/utils/async/every-by,@stdlib/utils/async/for-each,@stdlib/utils/none-by,@stdlib/utils/async/none-by-right,@stdlib/utils/async/some-by"
+"@stdlib/utils/none-by-right","@stdlib/utils/any-by-right,@stdlib/utils/every-by-right,@stdlib/utils/for-each-right,@stdlib/utils/none,@stdlib/utils/none-by,@stdlib/utils/some-by-right"
+"@stdlib/utils/async/none-by-right","@stdlib/utils/async/any-by-right,@stdlib/utils/async/every-by-right,@stdlib/utils/async/for-each-right,@stdlib/utils/async/none-by,@stdlib/utils/none-by-right,@stdlib/utils/async/some-by-right"
+"@stdlib/utils/nonenumerable-properties","@stdlib/utils/enumerable-properties,@stdlib/utils/inherited-nonenumerable-properties,@stdlib/utils/nonenumerable-properties-in,@stdlib/utils/properties"
+"@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/enumerable-properties-in,@stdlib/utils/inherited-nonenumerable-properties,@stdlib/utils/nonenumerable-properties,@stdlib/utils/properties-in"
+"@stdlib/utils/nonenumerable-property-names","@stdlib/utils/keys,@stdlib/utils/inherited-nonenumerable-property-names,@stdlib/utils/nonenumerable-property-names-in,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/property-names"
+"@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/keys-in,@stdlib/utils/inherited-nonenumerable-property-names,@stdlib/utils/nonenumerable-property-names,@stdlib/utils/property-names-in"
+"@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/enumerable-property-symbols,@stdlib/utils/inherited-nonenumerable-property-symbols,@stdlib/utils/nonenumerable-property-names,@stdlib/utils/nonenumerable-property-symbols-in,@stdlib/utils/property-symbols"
+"@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/enumerable-property-symbols-in,@stdlib/utils/inherited-nonenumerable-property-symbols,@stdlib/utils/nonenumerable-property-names-in,@stdlib/utils/nonenumerable-property-symbols,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/noop",""
+"@stdlib/time/now",""
+"@stdlib/os/num-cpus",""
+"@stdlib/number/ctor",""
+"@stdlib/utils/entries","@stdlib/utils/entries-in,@stdlib/utils/from-entries,@stdlib/utils/keys,@stdlib/utils/values"
+"@stdlib/utils/entries-in","@stdlib/utils/entries,@stdlib/utils/from-entries,@stdlib/utils/keys-in,@stdlib/utils/values-in"
+"@stdlib/utils/from-entries","@stdlib/utils/entries"
+"@stdlib/utils/object-inverse","@stdlib/utils/object-inverse-by"
+"@stdlib/utils/object-inverse-by","@stdlib/utils/object-inverse"
+"@stdlib/utils/keys","@stdlib/utils/entries,@stdlib/utils/keys-in,@stdlib/utils/values"
+"@stdlib/utils/values","@stdlib/utils/entries,@stdlib/utils/keys"
+"@stdlib/utils/values-in","@stdlib/utils/entries-in,@stdlib/utils/keys-in,@stdlib/utils/values"
+"@stdlib/utils/omit","@stdlib/utils/omit-by"
+"@stdlib/utils/omit-by","@stdlib/utils/omit"
+"@stdlib/ml/online-binary-classification","@stdlib/ml/online-sgd-regression"
+"@stdlib/ml/online-sgd-regression","@stdlib/ml/online-binary-classification"
+"@stdlib/utils/open-url",""
+"@stdlib/datasets/pace-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices,@stdlib/datasets/harrison-boston-house-prices-corrected"
+"@stdlib/string/pad","@stdlib/string/left-pad,@stdlib/string/right-pad"
+"@stdlib/utils/papply","@stdlib/utils/papply-right"
+"@stdlib/utils/papply-right","@stdlib/utils/papply"
+"@stdlib/utils/parallel",""
+"@stdlib/utils/parse-json",""
+"@stdlib/constants/string/path-delimiter","@stdlib/constants/string/path-delimiter-posix,@stdlib/constants/string/path-delimiter-win32"
+"@stdlib/constants/string/path-delimiter-posix","@stdlib/constants/string/path-delimiter,@stdlib/constants/string/path-delimiter-win32"
+"@stdlib/constants/string/path-delimiter-win32","@stdlib/constants/string/path-delimiter,@stdlib/constants/string/path-delimiter-posix"
+"@stdlib/constants/string/path-sep","@stdlib/constants/string/path-sep-posix,@stdlib/constants/string/path-sep-win32"
+"@stdlib/constants/string/path-sep-posix","@stdlib/constants/string/path-sep,@stdlib/constants/string/path-sep-win32"
+"@stdlib/constants/string/path-sep-win32","@stdlib/constants/string/path-sep,@stdlib/constants/string/path-sep-posix"
+"@stdlib/stats/pcorrtest",""
+"@stdlib/string/percent-encode",""
+"@stdlib/constants/math/float64-phi",""
+"@stdlib/constants/math/float64-pi","@stdlib/constants/math/float64-two-pi"
+"@stdlib/constants/math/float64-pi-squared","@stdlib/constants/math/float64-pi"
+"@stdlib/utils/pick","@stdlib/utils/pick-by"
+"@stdlib/utils/pick-by","@stdlib/utils/pick"
+"@stdlib/constants/math/float64-pinf","@stdlib/constants/math/float64-ninf"
+"@stdlib/namespace/pkg2alias","@stdlib/namespace/alias2pkg,@stdlib/namespace/aliases,@stdlib/namespace/pkg2related"
+"@stdlib/namespace/pkg2related","@stdlib/namespace/alias2related,@stdlib/namespace/aliases,@stdlib/namespace/pkg2alias"
+"@stdlib/os/platform","@stdlib/os/arch"
+"@stdlib/plot","@stdlib/plot/ctor"
+"@stdlib/plot/ctor","@stdlib/plot"
+"@stdlib/utils/pluck","@stdlib/utils/deep-pluck,@stdlib/utils/pick"
+"@stdlib/utils/pop","@stdlib/utils/push,@stdlib/utils/shift,@stdlib/utils/unshift"
+"@stdlib/utils/prepend","@stdlib/utils/append,@stdlib/utils/unshift"
+"@stdlib/utils/properties","@stdlib/utils/define-properties,@stdlib/utils/inherited-properties,@stdlib/utils/properties-in,@stdlib/utils/property-names,@stdlib/utils/property-symbols"
+"@stdlib/utils/properties-in","@stdlib/utils/define-properties,@stdlib/utils/inherited-properties,@stdlib/utils/properties,@stdlib/utils/property-names-in,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/property-descriptor","@stdlib/assert/has-own-property,@stdlib/utils/define-property,@stdlib/utils/property-descriptor-in,@stdlib/utils/property-descriptors"
+"@stdlib/utils/property-descriptor-in","@stdlib/assert/has-property,@stdlib/utils/define-property,@stdlib/utils/property-descriptor,@stdlib/utils/property-descriptors-in"
+"@stdlib/utils/property-descriptors","@stdlib/utils/define-property,@stdlib/utils/define-properties,@stdlib/utils/property-descriptor,@stdlib/utils/property-descriptors-in,@stdlib/utils/property-names,@stdlib/utils/property-symbols"
+"@stdlib/utils/property-descriptors-in","@stdlib/utils/define-properties,@stdlib/utils/property-descriptor-in,@stdlib/utils/property-descriptors,@stdlib/utils/property-names-in,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/property-names","@stdlib/utils/keys,@stdlib/utils/nonenumerable-property-names,@stdlib/utils/property-names-in,@stdlib/utils/property-symbols"
+"@stdlib/utils/property-names-in","@stdlib/utils/keys,@stdlib/utils/nonenumerable-property-names-in,@stdlib/utils/property-names,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/property-symbols","@stdlib/utils/property-names,@stdlib/utils/property-symbols-in"
+"@stdlib/utils/property-symbols-in","@stdlib/utils/property-names-in,@stdlib/utils/property-symbols"
+"@stdlib/proxy/ctor",""
+"@stdlib/utils/push","@stdlib/utils/pop,@stdlib/utils/shift,@stdlib/utils/unshift"
+"@stdlib/time/quarter-of-year","@stdlib/time/day-of-year"
+"@stdlib/random/iter/arcsine","@stdlib/random/base/arcsine"
+"@stdlib/random/iter/bernoulli","@stdlib/random/base/bernoulli"
+"@stdlib/random/iter/beta","@stdlib/random/base/beta"
+"@stdlib/random/iter/betaprime","@stdlib/random/base/betaprime"
+"@stdlib/random/iter/binomial","@stdlib/random/base/binomial"
+"@stdlib/random/iter/box-muller","@stdlib/random/base/box-muller"
+"@stdlib/random/iter/cauchy","@stdlib/random/base/cauchy"
+"@stdlib/random/iter/chi","@stdlib/random/base/chi"
+"@stdlib/random/iter/chisquare","@stdlib/random/base/chisquare"
+"@stdlib/random/iter/cosine","@stdlib/random/base/cosine"
+"@stdlib/random/iter/discrete-uniform","@stdlib/random/base/discrete-uniform"
+"@stdlib/random/iter/erlang","@stdlib/random/base/erlang"
+"@stdlib/random/iter/exponential","@stdlib/random/base/exponential"
+"@stdlib/random/iter/f","@stdlib/random/base/f"
+"@stdlib/random/iter/frechet","@stdlib/random/base/frechet"
+"@stdlib/random/iter/gamma","@stdlib/random/base/gamma"
+"@stdlib/random/iter/geometric","@stdlib/random/base/geometric"
+"@stdlib/random/iter/gumbel","@stdlib/random/base/gumbel"
+"@stdlib/random/iter/hypergeometric","@stdlib/random/base/hypergeometric"
+"@stdlib/random/iter/improved-ziggurat","@stdlib/random/base/improved-ziggurat"
+"@stdlib/random/iter/invgamma","@stdlib/random/base/invgamma"
+"@stdlib/random/iter/kumaraswamy","@stdlib/random/base/kumaraswamy"
+"@stdlib/random/iter/laplace","@stdlib/random/base/laplace"
+"@stdlib/random/iter/levy","@stdlib/random/base/levy"
+"@stdlib/random/iter/logistic","@stdlib/random/base/logistic"
+"@stdlib/random/iter/lognormal","@stdlib/random/base/lognormal"
+"@stdlib/random/iter/minstd","@stdlib/random/base/minstd,@stdlib/random/iter/minstd-shuffle,@stdlib/random/iter/mt19937,@stdlib/random/iter/randi,@stdlib/random/iter/randu"
+"@stdlib/random/iter/minstd-shuffle","@stdlib/random/base/minstd-shuffle,@stdlib/random/iter/minstd,@stdlib/random/iter/mt19937,@stdlib/random/iter/randi,@stdlib/random/iter/randu"
+"@stdlib/random/iter/mt19937","@stdlib/random/base/mt19937,@stdlib/random/iter/minstd,@stdlib/random/iter/minstd-shuffle,@stdlib/random/iter/randi,@stdlib/random/iter/randu"
+"@stdlib/random/iter/negative-binomial","@stdlib/random/base/negative-binomial"
+"@stdlib/random/iter/normal","@stdlib/random/base/normal"
+"@stdlib/random/iter/pareto-type1","@stdlib/random/base/pareto-type1"
+"@stdlib/random/iter/poisson","@stdlib/random/base/poisson"
+"@stdlib/random/iter/randi","@stdlib/random/base/randi,@stdlib/random/iter/randu"
+"@stdlib/random/iter/randn","@stdlib/random/base/randn"
+"@stdlib/random/iter/randu","@stdlib/random/base/randu,@stdlib/random/iter/randi"
+"@stdlib/random/iter/rayleigh","@stdlib/random/base/rayleigh"
+"@stdlib/random/iter/t","@stdlib/random/base/t"
+"@stdlib/random/iter/triangular","@stdlib/random/base/triangular"
+"@stdlib/random/iter/uniform","@stdlib/random/base/uniform"
+"@stdlib/random/iter/weibull","@stdlib/random/base/weibull"
+"@stdlib/random/streams/arcsine","@stdlib/random/base/arcsine,@stdlib/random/iter/arcsine"
+"@stdlib/random/streams/bernoulli","@stdlib/random/base/bernoulli,@stdlib/random/iter/bernoulli"
+"@stdlib/random/streams/beta","@stdlib/random/base/beta,@stdlib/random/iter/beta"
+"@stdlib/random/streams/betaprime","@stdlib/random/base/betaprime,@stdlib/random/iter/betaprime"
+"@stdlib/random/streams/binomial","@stdlib/random/base/binomial,@stdlib/random/iter/binomial"
+"@stdlib/random/streams/box-muller","@stdlib/random/base/box-muller,@stdlib/random/iter/box-muller,@stdlib/random/streams/improved-ziggurat,@stdlib/random/streams/randn"
+"@stdlib/random/streams/cauchy","@stdlib/random/base/cauchy,@stdlib/random/iter/cauchy"
+"@stdlib/random/streams/chi","@stdlib/random/base/chi,@stdlib/random/iter/chi"
+"@stdlib/random/streams/chisquare","@stdlib/random/base/chisquare,@stdlib/random/iter/chisquare"
+"@stdlib/random/streams/cosine","@stdlib/random/base/cosine,@stdlib/random/iter/cosine"
+"@stdlib/random/streams/discrete-uniform","@stdlib/random/base/discrete-uniform,@stdlib/random/iter/discrete-uniform"
+"@stdlib/random/streams/erlang","@stdlib/random/base/erlang,@stdlib/random/iter/erlang"
+"@stdlib/random/streams/exponential","@stdlib/random/base/exponential,@stdlib/random/iter/exponential"
+"@stdlib/random/streams/f","@stdlib/random/base/f,@stdlib/random/iter/f"
+"@stdlib/random/streams/gamma","@stdlib/random/base/gamma,@stdlib/random/iter/gamma"
+"@stdlib/random/streams/geometric","@stdlib/random/base/geometric,@stdlib/random/iter/geometric"
+"@stdlib/random/streams/gumbel","@stdlib/random/base/gumbel,@stdlib/random/iter/gumbel"
+"@stdlib/random/streams/improved-ziggurat","@stdlib/random/base/improved-ziggurat,@stdlib/random/iter/improved-ziggurat,@stdlib/random/streams/box-muller,@stdlib/random/streams/randn"
+"@stdlib/random/streams/invgamma","@stdlib/random/base/invgamma,@stdlib/random/iter/invgamma"
+"@stdlib/random/streams/kumaraswamy","@stdlib/random/base/kumaraswamy,@stdlib/random/iter/kumaraswamy"
+"@stdlib/random/streams/laplace","@stdlib/random/base/laplace,@stdlib/random/iter/laplace"
+"@stdlib/random/streams/levy","@stdlib/random/base/levy,@stdlib/random/iter/levy"
+"@stdlib/random/streams/logistic","@stdlib/random/base/logistic,@stdlib/random/iter/logistic"
+"@stdlib/random/streams/lognormal","@stdlib/random/base/lognormal,@stdlib/random/iter/lognormal"
+"@stdlib/random/streams/minstd","@stdlib/random/base/minstd,@stdlib/random/iter/minstd,@stdlib/random/streams/minstd-shuffle,@stdlib/random/streams/mt19937,@stdlib/random/streams/randi,@stdlib/random/streams/randu"
+"@stdlib/random/streams/minstd-shuffle","@stdlib/random/base/minstd-shuffle,@stdlib/random/iter/minstd-shuffle,@stdlib/random/streams/minstd,@stdlib/random/streams/mt19937,@stdlib/random/streams/randi,@stdlib/random/streams/randu"
+"@stdlib/random/streams/mt19937","@stdlib/random/base/mt19937,@stdlib/random/iter/mt19937,@stdlib/random/streams/minstd,@stdlib/random/streams/minstd-shuffle,@stdlib/random/streams/randi,@stdlib/random/streams/randu"
+"@stdlib/random/streams/negative-binomial","@stdlib/random/base/negative-binomial,@stdlib/random/iter/negative-binomial"
+"@stdlib/random/streams/normal","@stdlib/random/base/normal,@stdlib/random/iter/normal"
+"@stdlib/random/streams/pareto-type1","@stdlib/random/base/pareto-type1,@stdlib/random/iter/pareto-type1"
+"@stdlib/random/streams/poisson","@stdlib/random/base/poisson,@stdlib/random/iter/poisson"
+"@stdlib/random/streams/randi","@stdlib/random/base/randi,@stdlib/random/iter/randi,@stdlib/random/streams/randu"
+"@stdlib/random/streams/randn","@stdlib/random/base/randn,@stdlib/random/iter/randn,@stdlib/random/streams/box-muller,@stdlib/random/streams/improved-ziggurat"
+"@stdlib/random/streams/randu","@stdlib/random/base/randu,@stdlib/random/iter/randu,@stdlib/random/streams/randi"
+"@stdlib/random/streams/rayleigh","@stdlib/random/base/rayleigh,@stdlib/random/iter/rayleigh"
+"@stdlib/random/streams/t","@stdlib/random/base/t,@stdlib/random/iter/t"
+"@stdlib/random/streams/uniform","@stdlib/random/base/uniform,@stdlib/random/iter/uniform"
+"@stdlib/random/streams/weibull","@stdlib/random/base/weibull,@stdlib/random/iter/weibull"
+"@stdlib/stats/ranks",""
+"@stdlib/regexp/basename","@stdlib/regexp/basename-posix,@stdlib/regexp/basename-windows"
+"@stdlib/regexp/basename-posix","@stdlib/regexp/basename,@stdlib/regexp/basename-windows"
+"@stdlib/regexp/basename-windows","@stdlib/regexp/basename,@stdlib/regexp/basename-posix"
+"@stdlib/regexp/color-hexadecimal",""
+"@stdlib/regexp/decimal-number",""
+"@stdlib/regexp/dirname","@stdlib/regexp/dirname-posix,@stdlib/regexp/dirname-windows,@stdlib/utils/dirname"
+"@stdlib/regexp/dirname-posix","@stdlib/regexp/dirname,@stdlib/regexp/dirname-windows,@stdlib/utils/dirname"
+"@stdlib/regexp/dirname-windows","@stdlib/regexp/dirname,@stdlib/regexp/dirname-posix,@stdlib/utils/dirname"
+"@stdlib/regexp/eol",""
+"@stdlib/regexp/extended-length-path",""
+"@stdlib/regexp/extname","@stdlib/regexp/extname-posix,@stdlib/regexp/extname-windows,@stdlib/utils/extname"
+"@stdlib/regexp/extname-posix","@stdlib/regexp/extname,@stdlib/regexp/extname-windows,@stdlib/utils/extname"
+"@stdlib/regexp/extname-windows","@stdlib/regexp/extname,@stdlib/regexp/extname-posix,@stdlib/utils/extname"
+"@stdlib/regexp/filename","@stdlib/regexp/filename-posix,@stdlib/regexp/filename-windows"
+"@stdlib/regexp/filename-posix","@stdlib/regexp/filename,@stdlib/regexp/filename-windows"
+"@stdlib/regexp/filename-windows","@stdlib/regexp/filename,@stdlib/regexp/filename-posix"
+"@stdlib/regexp/function-name","@stdlib/utils/function-name"
+"@stdlib/regexp/native-function","@stdlib/regexp/function-name,@stdlib/utils/function-name"
+"@stdlib/regexp/regexp","@stdlib/utils/regexp-from-string"
+"@stdlib/regexp/unc-path","@stdlib/assert/is-unc-path"
+"@stdlib/regexp/utf16-surrogate-pair","@stdlib/regexp/utf16-unpaired-surrogate"
+"@stdlib/regexp/utf16-unpaired-surrogate","@stdlib/regexp/utf16-surrogate-pair"
+"@stdlib/regexp/whitespace","@stdlib/assert/is-whitespace"
+"@stdlib/fs/read-dir","@stdlib/fs/exists,@stdlib/fs/read-file"
+"@stdlib/fs/read-file","@stdlib/fs/exists,@stdlib/fs/read-dir,@stdlib/fs/read-json,@stdlib/fs/write-file"
+"@stdlib/fs/read-file-list",""
+"@stdlib/fs/read-json","@stdlib/fs/read-file"
+"@stdlib/fs/read-wasm","@stdlib/fs/read-file"
+"@stdlib/complex/real","@stdlib/complex/imag,@stdlib/complex/reim"
+"@stdlib/utils/real-max","@stdlib/utils/real-min,@stdlib/utils/type-max"
+"@stdlib/utils/real-min","@stdlib/utils/real-max,@stdlib/utils/type-min"
+"@stdlib/utils/reduce","@stdlib/utils/for-each,@stdlib/utils/async/reduce,@stdlib/utils/reduce-right"
+"@stdlib/utils/async/reduce","@stdlib/utils/async/for-each,@stdlib/utils/reduce,@stdlib/utils/async/reduce-right"
+"@stdlib/utils/reduce-right","@stdlib/utils/for-each-right,@stdlib/utils/reduce,@stdlib/utils/async/reduce-right"
+"@stdlib/utils/async/reduce-right","@stdlib/utils/async/for-each-right,@stdlib/utils/async/reduce,@stdlib/utils/reduce-right"
+"@stdlib/utils/regexp-from-string",""
+"@stdlib/complex/reim","@stdlib/complex/imag,@stdlib/complex/real"
+"@stdlib/string/remove-first","@stdlib/string/remove-last"
+"@stdlib/string/remove-last","@stdlib/string/remove-first"
+"@stdlib/string/remove-punctuation",""
+"@stdlib/string/remove-utf8-bom",""
+"@stdlib/string/remove-words",""
+"@stdlib/fs/rename","@stdlib/fs/exists,@stdlib/fs/read-file,@stdlib/fs/write-file,@stdlib/fs/unlink"
+"@stdlib/utils/reorder-arguments","@stdlib/utils/reverse-arguments"
+"@stdlib/string/repeat","@stdlib/string/pad"
+"@stdlib/string/replace",""
+"@stdlib/utils/escape-regexp-string",""
+"@stdlib/fs/resolve-parent-path",""
+"@stdlib/utils/reverse-arguments","@stdlib/utils/reorder-arguments"
+"@stdlib/string/reverse",""
+"@stdlib/random/base/reviver",""
+"@stdlib/buffer/reviver","@stdlib/buffer/to-json"
+"@stdlib/complex/reviver","@stdlib/complex/float64,@stdlib/complex/float32,@stdlib/complex/reviver-float64,@stdlib/complex/reviver-float32"
+"@stdlib/complex/reviver-float32","@stdlib/complex/float32,@stdlib/complex/reviver-float64,@stdlib/complex/reviver"
+"@stdlib/complex/reviver-float64","@stdlib/complex/float64,@stdlib/complex/reviver-float32,@stdlib/complex/reviver"
+"@stdlib/error/reviver","@stdlib/error/to-json"
+"@stdlib/array/reviver","@stdlib/array/to-json"
+"@stdlib/string/right-pad","@stdlib/string/left-pad,@stdlib/string/pad"
+"@stdlib/string/right-trim","@stdlib/string/left-trim,@stdlib/string/trim"
+"@stdlib/utils/safe-int-max","@stdlib/utils/safe-int-min,@stdlib/utils/real-max,@stdlib/utils/type-max"
+"@stdlib/utils/safe-int-min","@stdlib/utils/safe-int-max,@stdlib/utils/real-min,@stdlib/utils/type-min"
+"@stdlib/random/sample",""
+"@stdlib/datasets/savoy-stopwords-fin",""
+"@stdlib/datasets/savoy-stopwords-fr",""
+"@stdlib/datasets/savoy-stopwords-ger",""
+"@stdlib/datasets/savoy-stopwords-it",""
+"@stdlib/datasets/savoy-stopwords-por",""
+"@stdlib/datasets/savoy-stopwords-sp",""
+"@stdlib/datasets/savoy-stopwords-swe",""
+"@stdlib/constants/time/seconds-in-day",""
+"@stdlib/constants/time/seconds-in-hour",""
+"@stdlib/constants/time/seconds-in-minute",""
+"@stdlib/constants/time/seconds-in-week",""
+"@stdlib/time/seconds-in-month","@stdlib/time/seconds-in-year"
+"@stdlib/time/seconds-in-year","@stdlib/time/seconds-in-month"
+"@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor,@stdlib/utils/define-configurable-read-write-accessor,@stdlib/utils/define-property,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-only-property,@stdlib/utils/define-configurable-read-write-accessor,@stdlib/utils/define-configurable-write-only-accessor,@stdlib/utils/define-property,@stdlib/utils/define-read-only-accessor"
+"@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-configurable-read-only-property,@stdlib/utils/define-configurable-read-only-accessor,@stdlib/utils/define-configurable-write-only-accessor,@stdlib/utils/define-property,@stdlib/utils/define-read-write-accessor"
+"@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-configurable-read-only-property,@stdlib/utils/define-configurable-read-only-accessor,@stdlib/utils/define-configurable-read-write-accessor,@stdlib/utils/define-property,@stdlib/utils/define-write-only-accessor"
+"@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-memoized-property,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor,@stdlib/utils/define-nonenumerable-read-only-property,@stdlib/utils/define-nonenumerable-read-write-accessor,@stdlib/utils/define-nonenumerable-write-only-accessor,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-property,@stdlib/utils/define-nonenumerable-read-only-accessor,@stdlib/utils/define-nonenumerable-read-write-accessor,@stdlib/utils/define-nonenumerable-write-only-accessor,@stdlib/utils/define-read-only-property"
+"@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-property,@stdlib/utils/define-nonenumerable-read-only-property,@stdlib/utils/define-nonenumerable-read-write-accessor,@stdlib/utils/define-nonenumerable-write-only-accessor,@stdlib/utils/define-read-only-accessor"
+"@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-property,@stdlib/utils/define-nonenumerable-read-only-accessor,@stdlib/utils/define-nonenumerable-read-only-property,@stdlib/utils/define-nonenumerable-write-only-accessor,@stdlib/utils/define-read-write-accessor"
+"@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-nonenumerable-property,@stdlib/utils/define-nonenumerable-read-only-accessor,@stdlib/utils/define-nonenumerable-read-only-property,@stdlib/utils/define-nonenumerable-read-write-accessor,@stdlib/utils/define-write-only-accessor"
+"@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor,@stdlib/utils/define-read-write-accessor,@stdlib/utils/define-write-only-accessor"
+"@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-only-property,@stdlib/utils/define-read-write-accessor,@stdlib/utils/define-write-only-accessor"
+"@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-read-only-property,@stdlib/utils/define-read-only-accessor,@stdlib/utils/define-write-only-accessor"
+"@stdlib/utils/define-write-only-accessor","@stdlib/utils/define-read-only-property,@stdlib/utils/define-read-only-accessor,@stdlib/utils/define-read-write-accessor"
+"@stdlib/array/shared-buffer","@stdlib/buffer/ctor,@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/utils/shift","@stdlib/utils/pop,@stdlib/utils/push,@stdlib/utils/unshift"
+"@stdlib/random/shuffle","@stdlib/random/sample"
+"@stdlib/utils/size-of","@stdlib/utils/real-max,@stdlib/utils/type-max"
+"@stdlib/utils/some","@stdlib/utils/any,@stdlib/utils/every,@stdlib/utils/for-each,@stdlib/utils/none,@stdlib/utils/some-by"
+"@stdlib/utils/some-by","@stdlib/utils/any-by,@stdlib/utils/every-by,@stdlib/utils/for-each,@stdlib/utils/none-by,@stdlib/utils/async/some-by,@stdlib/utils/some-by-right"
+"@stdlib/utils/async/some-by","@stdlib/utils/async/any-by,@stdlib/utils/async/every-by,@stdlib/utils/async/for-each,@stdlib/utils/async/none-by,@stdlib/utils/some-by,@stdlib/utils/async/some-by-right"
+"@stdlib/utils/some-by-right","@stdlib/utils/any-by-right,@stdlib/utils/every-by-right,@stdlib/utils/for-each-right,@stdlib/utils/none-by-right,@stdlib/utils/some-by,@stdlib/utils/async/some-by-right"
+"@stdlib/utils/async/some-by-right","@stdlib/utils/async/any-by-right,@stdlib/utils/async/every-by-right,@stdlib/utils/async/for-each-right,@stdlib/utils/async/none-by-right,@stdlib/utils/async/some-by,@stdlib/utils/some-by-right"
+"@stdlib/datasets/sotu",""
+"@stdlib/datasets/spache-revised",""
+"@stdlib/datasets/spam-assassin",""
+"@stdlib/plot/sparklines/base/ctor","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/array/to-sparse-iterator","@stdlib/array/from-iterator,@stdlib/array/to-iterator,@stdlib/array/to-sparse-iterator-right"
+"@stdlib/array/to-sparse-iterator-right","@stdlib/array/from-iterator,@stdlib/array/to-iterator-right,@stdlib/array/to-sparse-iterator"
+"@stdlib/streams/node/split","@stdlib/streams/node/join"
+"@stdlib/constants/math/float64-sqrt-eps","@stdlib/constants/math/float64-eps"
+"@stdlib/constants/math/float64-sqrt-half","@stdlib/constants/math/float64-ln-half"
+"@stdlib/constants/math/float64-sqrt-half-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/constants/math/float64-sqrt-phi","@stdlib/constants/math/float64-phi"
+"@stdlib/constants/math/float64-sqrt-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/constants/math/float64-sqrt-three",""
+"@stdlib/constants/math/float64-sqrt-two","@stdlib/constants/math/float64-ln-two"
+"@stdlib/constants/math/float64-sqrt-two-pi","@stdlib/constants/math/float64-two-pi"
+"@stdlib/utils/stack","@stdlib/utils/fifo"
+"@stdlib/string/startcase","@stdlib/string/lowercase,@stdlib/string/uppercase"
+"@stdlib/string/starts-with","@stdlib/string/ends-with"
+"@stdlib/datasets/stopwords-en",""
+"@stdlib/array/to-strided-iterator","@stdlib/array/from-iterator,@stdlib/array/to-iterator"
+"@stdlib/streams/node/from-strided-array","@stdlib/streams/node/from-array"
+"@stdlib/buffer/from-string","@stdlib/buffer/ctor,@stdlib/buffer/from-array,@stdlib/buffer/from-arraybuffer,@stdlib/buffer/from-buffer"
+"@stdlib/ndarray/sub2ind","@stdlib/ndarray/array,@stdlib/ndarray/ctor,@stdlib/ndarray/ind2sub"
+"@stdlib/datasets/suthaharan-multi-hop-sensor-network","@stdlib/datasets/suthaharan-single-hop-sensor-network"
+"@stdlib/datasets/suthaharan-single-hop-sensor-network","@stdlib/datasets/suthaharan-multi-hop-sensor-network"
+"@stdlib/symbol/ctor",""
+"@stdlib/utils/tabulate","@stdlib/utils/count-by,@stdlib/utils/group-by,@stdlib/utils/tabulate-by"
+"@stdlib/utils/tabulate-by","@stdlib/utils/count-by,@stdlib/utils/group-by,@stdlib/utils/tabulate"
+"@stdlib/utils/async/tabulate-by","@stdlib/utils/async/count-by,@stdlib/utils/async/group-by,@stdlib/utils/tabulate-by"
+"@stdlib/time/tic","@stdlib/time/toc"
+"@stdlib/utils/timeit",""
+"@stdlib/os/tmpdir","@stdlib/os/configdir,@stdlib/os/homedir"
+"@stdlib/time/toc","@stdlib/time/tic"
+"@stdlib/nlp/tokenize",""
+"@stdlib/streams/node/transform",""
+"@stdlib/string/trim","@stdlib/string/left-trim,@stdlib/string/pad,@stdlib/string/right-trim"
+"@stdlib/utils/try-catch","@stdlib/utils/async/try-catch,@stdlib/utils/try-then"
+"@stdlib/utils/async/try-catch","@stdlib/utils/try-catch,@stdlib/utils/async/try-then"
+"@stdlib/utils/try-function",""
+"@stdlib/utils/try-require",""
+"@stdlib/utils/try-then","@stdlib/utils/try-catch,@stdlib/utils/async/try-then"
+"@stdlib/utils/async/try-then","@stdlib/utils/async/try-catch,@stdlib/utils/try-then"
+"@stdlib/stats/ttest","@stdlib/stats/ttest2"
+"@stdlib/stats/ttest2","@stdlib/stats/ttest"
+"@stdlib/constants/math/float64-two-pi","@stdlib/constants/math/float64-pi"
+"@stdlib/array/typed","@stdlib/array/float64,@stdlib/array/float32,@stdlib/array/int32,@stdlib/array/uint32,@stdlib/array/int16,@stdlib/array/uint16,@stdlib/array/int8,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/array/to-json","@stdlib/array/reviver"
+"@stdlib/array/typed-complex-ctors","@stdlib/array/ctors,@stdlib/array/typed-ctors"
+"@stdlib/array/typed-complex-dtypes","@stdlib/array/dtypes,@stdlib/array/typed-dtypes,@stdlib/ndarray/dtypes"
+"@stdlib/array/typed-ctors","@stdlib/array/ctors"
+"@stdlib/array/typed-dtypes","@stdlib/array/dtypes,@stdlib/ndarray/dtypes"
+"@stdlib/array/pool","@stdlib/array/typed"
+"@stdlib/utils/type-max","@stdlib/utils/real-max,@stdlib/utils/type-min"
+"@stdlib/utils/type-min","@stdlib/utils/real-min,@stdlib/utils/type-max"
+"@stdlib/utils/type-of","@stdlib/utils/constructor-name,@stdlib/utils/native-class"
+"@stdlib/constants/math/uint8-max","@stdlib/constants/math/int8-max"
+"@stdlib/constants/math/uint8-num-bytes","@stdlib/constants/math/int8-num-bytes,@stdlib/constants/math/uint16-num-bytes,@stdlib/constants/math/uint32-num-bytes"
+"@stdlib/array/uint8","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8c"
+"@stdlib/array/uint8c","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint32,@stdlib/array/uint8"
+"@stdlib/constants/math/uint16-max","@stdlib/constants/math/int16-max"
+"@stdlib/constants/math/uint16-num-bytes","@stdlib/constants/math/int16-num-bytes,@stdlib/constants/math/uint32-num-bytes,@stdlib/constants/math/uint8-num-bytes"
+"@stdlib/array/uint16","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint32,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/constants/math/uint32-max","@stdlib/constants/math/int32-max"
+"@stdlib/constants/math/uint32-num-bytes","@stdlib/constants/math/int32-num-bytes,@stdlib/constants/math/uint16-num-bytes,@stdlib/constants/math/uint8-num-bytes"
+"@stdlib/array/uint32","@stdlib/array/buffer,@stdlib/array/float32,@stdlib/array/float64,@stdlib/array/int16,@stdlib/array/int32,@stdlib/array/int8,@stdlib/array/uint16,@stdlib/array/uint8,@stdlib/array/uint8c"
+"@stdlib/process/umask",""
+"@stdlib/string/uncapitalize","@stdlib/string/capitalize,@stdlib/string/lowercase"
+"@stdlib/utils/uncapitalize-keys","@stdlib/utils/capitalize-keys,@stdlib/utils/lowercase-keys"
+"@stdlib/utils/uncurry","@stdlib/utils/curry,@stdlib/utils/uncurry-right"
+"@stdlib/utils/uncurry-right","@stdlib/utils/curry,@stdlib/utils/curry-right,@stdlib/utils/uncurry"
+"@stdlib/constants/string/unicode-max","@stdlib/constants/string/unicode-max-bmp"
+"@stdlib/constants/string/unicode-max-bmp","@stdlib/constants/string/unicode-max"
+"@stdlib/plot/sparklines/unicode/column","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/up-down,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/plot/sparklines/unicode/line","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/up-down,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/plot/sparklines/unicode","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/up-down,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/up-down,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/win-loss"
+"@stdlib/plot/sparklines/unicode/win-loss","@stdlib/plot,@stdlib/plot/ctor,@stdlib/plot/sparklines/unicode,@stdlib/plot/sparklines/unicode/column,@stdlib/plot/sparklines/unicode/line,@stdlib/plot/sparklines/unicode/tristate,@stdlib/plot/sparklines/unicode/up-down"
+"@stdlib/fs/unlink","@stdlib/fs/exists"
+"@stdlib/utils/unshift","@stdlib/utils/pop,@stdlib/utils/push,@stdlib/utils/shift"
+"@stdlib/utils/until","@stdlib/utils/do-until,@stdlib/utils/do-while,@stdlib/utils/async/until,@stdlib/utils/until-each,@stdlib/utils/while"
+"@stdlib/utils/async/until","@stdlib/utils/async/do-until,@stdlib/utils/async/do-while,@stdlib/utils/until,@stdlib/utils/async/while"
+"@stdlib/utils/until-each","@stdlib/utils/until-each-right,@stdlib/utils/while-each"
+"@stdlib/utils/until-each-right","@stdlib/utils/until-each,@stdlib/utils/while-each-right"
+"@stdlib/utils/unzip","@stdlib/utils/zip"
+"@stdlib/string/uppercase","@stdlib/string/capitalize,@stdlib/string/lowercase"
+"@stdlib/utils/uppercase-keys","@stdlib/utils/capitalize-keys,@stdlib/utils/lowercase-keys"
+"@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals,@stdlib/datasets/us-states-names"
+"@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-abbr,@stdlib/datasets/us-states-capitals-names,@stdlib/datasets/us-states-names,@stdlib/datasets/us-states-names-capitals"
+"@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-capitals,@stdlib/datasets/us-states-names,@stdlib/datasets/us-states-names-capitals"
+"@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-abbr,@stdlib/datasets/us-states-capitals,@stdlib/datasets/us-states-capitals-names,@stdlib/datasets/us-states-names-capitals"
+"@stdlib/datasets/us-states-names-capitals","@stdlib/datasets/us-states-capitals,@stdlib/datasets/us-states-names,@stdlib/datasets/us-states-names-capitals"
+"@stdlib/string/utf16-to-utf8-array",""
+"@stdlib/stats/vartest","@stdlib/stats/bartlett-test"
+"@stdlib/utils/async/series-waterfall",""
+"@stdlib/utils/async/while","@stdlib/utils/async/do-until,@stdlib/utils/async/do-while,@stdlib/utils/async/until,@stdlib/utils/while"
+"@stdlib/utils/while-each","@stdlib/utils/until-each,@stdlib/utils/while-each-right"
+"@stdlib/utils/while-each-right","@stdlib/utils/while-each,@stdlib/utils/until-each-right"
+"@stdlib/utils/while","@stdlib/utils/do-until,@stdlib/utils/do-while,@stdlib/utils/until,@stdlib/utils/async/while,@stdlib/utils/while-each"
+"@stdlib/utils/writable-properties","@stdlib/utils/inherited-writable-properties,@stdlib/utils/writable-properties-in,@stdlib/utils/properties"
+"@stdlib/utils/writable-properties-in","@stdlib/utils/inherited-writable-properties,@stdlib/utils/writable-properties,@stdlib/utils/properties-in"
+"@stdlib/utils/writable-property-names","@stdlib/utils/inherited-writable-property-names,@stdlib/utils/writable-properties,@stdlib/utils/writable-property-names-in,@stdlib/utils/writable-property-symbols,@stdlib/utils/property-names"
+"@stdlib/utils/writable-property-names-in","@stdlib/utils/inherited-writable-property-names,@stdlib/utils/writable-properties-in,@stdlib/utils/writable-property-names,@stdlib/utils/writable-property-symbols-in,@stdlib/utils/property-names-in"
+"@stdlib/utils/writable-property-symbols","@stdlib/utils/inherited-writable-property-symbols,@stdlib/utils/writable-properties,@stdlib/utils/writable-property-names,@stdlib/utils/writable-property-symbols-in,@stdlib/utils/property-symbols"
+"@stdlib/utils/writable-property-symbols-in","@stdlib/utils/inherited-writable-property-symbols,@stdlib/utils/writable-properties-in,@stdlib/utils/writable-property-names-in,@stdlib/utils/writable-property-symbols,@stdlib/utils/property-symbols-in"
+"@stdlib/fs/write-file","@stdlib/fs/exists,@stdlib/fs/read-file"
+"@stdlib/utils/zip","@stdlib/utils/unzip"
+"@stdlib/stats/ztest","@stdlib/stats/ztest2"
+"@stdlib/stats/ztest2","@stdlib/stats/ztest"
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json
new file mode 100644
index 000000000000..b819c9c340d1
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/data/data.json
@@ -0,0 +1 @@
+{"@stdlib/datasets/afinn-96":["@stdlib/datasets/afinn-111"],"@stdlib/datasets/afinn-111":["@stdlib/datasets/afinn-96"],"@stdlib/namespace/alias2pkg":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/namespace/alias2related":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/aliases":["@stdlib/namespace/alias2pkg","@stdlib/namespace/alias2related","@stdlib/namespace/pkg2alias"],"@stdlib/buffer/alloc-unsafe":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/stats/anova1":[],"@stdlib/datasets/anscombes-quartet":[],"@stdlib/utils/any":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/any-by":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/any-by":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/any-by-right":["@stdlib/utils/any-by","@stdlib/utils/async/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/any-by-right":["@stdlib/utils/async/any-by","@stdlib/utils/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/constants/math/float64-apery":[],"@stdlib/utils/append":["@stdlib/utils/prepend","@stdlib/utils/push"],"@stdlib/os/arch":["@stdlib/os/platform"],"@stdlib/utils/argument-function":["@stdlib/utils/constant-function","@stdlib/utils/identity-function"],"@stdlib/process/argv":["@stdlib/process/env"],"@stdlib/ndarray/array":["@stdlib/ndarray/ctor"],"@stdlib/buffer/from-array":["@stdlib/buffer/ctor","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/to-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-circular-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator"],"@stdlib/array/to-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/array/buffer":["@stdlib/buffer/ctor","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/shared-buffer","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/buffer/from-arraybuffer":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-buffer","@stdlib/buffer/from-string"],"@stdlib/array/ctors":["@stdlib/array/typed-ctors"],"@stdlib/array/dtype":["@stdlib/array/dtypes"],"@stdlib/array/dtypes":["@stdlib/array/typed-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/min-dtype":["@stdlib/array/dtypes","@stdlib/array/promotion-rules","@stdlib/array/safe-casts"],"@stdlib/array/next-dtype":["@stdlib/array/dtype","@stdlib/array/dtypes"],"@stdlib/array/promotion-rules":["@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/promotion-rules"],"@stdlib/array/safe-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/same-kind-casts","@stdlib/ndarray/safe-casts"],"@stdlib/array/same-kind-casts":["@stdlib/array/convert","@stdlib/array/convert-same","@stdlib/array/dtypes","@stdlib/array/safe-casts","@stdlib/ndarray/same-kind-casts"],"@stdlib/array/shape":["@stdlib/ndarray/ctor"],"@stdlib/streams/node/from-array":["@stdlib/streams/node/from-circular-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/array/to-view-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator-right"],"@stdlib/array/to-view-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-strided-iterator","@stdlib/array/to-view-iterator"],"@stdlib/symbol/async-iterator":["@stdlib/symbol/ctor","@stdlib/symbol/iterator"],"@stdlib/stats/bartlett-test":["@stdlib/stats/vartest"],"@stdlib/math/base/special/abs":["@stdlib/math/base/special/abs2"],"@stdlib/math/base/special/abs2":["@stdlib/math/base/special/abs"],"@stdlib/math/base/utils/absolute-difference":["@stdlib/math/base/utils/relative-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/math/base/special/int32-abs":["@stdlib/math/base/special/abs"],"@stdlib/math/base/special/acos":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/acosh":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acoth":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/acovercos":["@stdlib/math/base/special/acoversin","@stdlib/math/base/special/avercos","@stdlib/math/base/special/covercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/acoversin":["@stdlib/math/base/special/acovercos","@stdlib/math/base/special/aversin","@stdlib/math/base/special/coversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/ahavercos":["@stdlib/math/base/special/ahaversin","@stdlib/math/base/special/havercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/ahaversin":["@stdlib/math/base/special/ahavercos","@stdlib/math/base/special/haversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/asin":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/asinh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan":["@stdlib/math/base/special/acos","@stdlib/math/base/special/asin","@stdlib/math/base/special/atanh"],"@stdlib/math/base/special/atan2":["@stdlib/math/base/special/atan"],"@stdlib/math/base/special/atanh":["@stdlib/math/base/special/acosh","@stdlib/math/base/special/asinh","@stdlib/math/base/special/atan"],"@stdlib/math/base/special/avercos":["@stdlib/math/base/special/aversin","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/aversin":["@stdlib/math/base/special/avercos","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/bernoulli":[],"@stdlib/math/base/special/besselj0":["@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/besselj1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/bessely0","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely0":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely1"],"@stdlib/math/base/special/bessely1":["@stdlib/math/base/special/besselj0","@stdlib/math/base/special/besselj1","@stdlib/math/base/special/bessely0"],"@stdlib/math/base/special/beta":["@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betainc":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betaincinv","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaincinv":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaln"],"@stdlib/math/base/special/betaln":["@stdlib/math/base/special/beta","@stdlib/math/base/special/betainc","@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/binet":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/binomcoef":[],"@stdlib/math/base/special/binomcoefln":[],"@stdlib/math/base/special/boxcox":["@stdlib/math/base/special/boxcoxinv","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/special/boxcox1p":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1pinv","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcox1pinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcoxinv"],"@stdlib/math/base/special/boxcoxinv":["@stdlib/math/base/special/boxcox","@stdlib/math/base/special/boxcox1p","@stdlib/math/base/special/boxcox1pinv"],"@stdlib/math/base/complex/abs":["@stdlib/math/base/complex/abs2","@stdlib/math/base/special/abs"],"@stdlib/math/base/complex/abs2":["@stdlib/math/base/complex/abs","@stdlib/math/base/special/abs2"],"@stdlib/math/base/complex/add":["@stdlib/math/base/complex/divide","@stdlib/math/base/complex/multiply","@stdlib/math/base/complex/subtract"],"@stdlib/math/base/special/cbrt":["@stdlib/math/base/special/pow","@stdlib/math/base/special/sqrt"],"@stdlib/math/base/complex/ceil":["@stdlib/math/base/complex/ceiln","@stdlib/math/base/complex/floor","@stdlib/math/base/complex/round"],"@stdlib/math/base/complex/ceiln":["@stdlib/math/base/complex/ceil","@stdlib/math/base/complex/floorn","@stdlib/math/base/complex/roundn"],"@stdlib/math/base/complex/cis":[],"@stdlib/math/base/complex/divide":["@stdlib/math/base/complex/add","@stdlib/math/base/complex/multiply","@stdlib/math/base/complex/subtract"],"@stdlib/math/base/special/ceil":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/ceil2":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/ceil10":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/ceilb":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/ceiln":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/ceilsd":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/complex/exp":[],"@stdlib/math/base/complex/flipsign":["@stdlib/math/base/complex/negate","@stdlib/math/base/complex/signum"],"@stdlib/math/base/complex/floor":["@stdlib/math/base/complex/ceil","@stdlib/math/base/complex/floorn","@stdlib/math/base/complex/round"],"@stdlib/math/base/complex/floorn":["@stdlib/math/base/complex/ceiln","@stdlib/math/base/complex/floor","@stdlib/math/base/complex/roundn"],"@stdlib/math/base/complex/inv":["@stdlib/math/base/complex/divide"],"@stdlib/math/base/special/clamp":["@stdlib/math/base/special/wrap"],"@stdlib/math/base/complex/multiply":["@stdlib/math/base/complex/add","@stdlib/math/base/complex/divide","@stdlib/math/base/complex/subtract"],"@stdlib/math/base/complex/negate":["@stdlib/math/base/complex/abs"],"@stdlib/math/base/tools/continued-fraction":[],"@stdlib/math/base/special/copysign":["@stdlib/math/base/special/flipsign"],"@stdlib/math/base/special/cos":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/cosm1","@stdlib/math/base/special/sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/cosh":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/cosm1":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/cospi":["@stdlib/math/base/special/cos"],"@stdlib/math/base/special/covercos":["@stdlib/math/base/special/coversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/coversin":["@stdlib/math/base/special/covercos","@stdlib/math/base/special/versin"],"@stdlib/math/base/complex/phase":["@stdlib/math/base/complex/abs"],"@stdlib/math/base/complex/polar":["@stdlib/math/base/complex/abs","@stdlib/math/base/complex/phase"],"@stdlib/math/base/complex/round":["@stdlib/math/base/complex/ceil","@stdlib/math/base/complex/floor","@stdlib/math/base/complex/roundn"],"@stdlib/math/base/complex/roundn":["@stdlib/math/base/complex/ceiln","@stdlib/math/base/complex/floorn","@stdlib/math/base/complex/round"],"@stdlib/math/base/complex/signum":["@stdlib/math/base/special/signum"],"@stdlib/math/base/complex/subtract":["@stdlib/math/base/complex/add","@stdlib/math/base/complex/divide","@stdlib/math/base/complex/multiply"],"@stdlib/blas/base/dasum":["@stdlib/blas/base/daxpy","@stdlib/blas/base/dcopy"],"@stdlib/blas/base/daxpy":["@stdlib/blas/base/dasum","@stdlib/blas/base/dcopy"],"@stdlib/blas/base/dcopy":["@stdlib/blas/base/dasum","@stdlib/blas/base/daxpy"],"@stdlib/math/base/special/deg2rad":["@stdlib/math/base/special/rad2deg"],"@stdlib/math/base/special/digamma":["@stdlib/math/base/special/trigamma","@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/dirac-delta":["@stdlib/math/base/special/kronecker-delta"],"@stdlib/stats/base/dists/arcsine/ctor":[],"@stdlib/stats/base/dists/arcsine/cdf":[],"@stdlib/stats/base/dists/arcsine/entropy":[],"@stdlib/stats/base/dists/arcsine/kurtosis":[],"@stdlib/stats/base/dists/arcsine/logcdf":[],"@stdlib/stats/base/dists/arcsine/logpdf":[],"@stdlib/stats/base/dists/arcsine/mean":[],"@stdlib/stats/base/dists/arcsine/median":[],"@stdlib/stats/base/dists/arcsine/mode":[],"@stdlib/stats/base/dists/arcsine/pdf":[],"@stdlib/stats/base/dists/arcsine/quantile":[],"@stdlib/stats/base/dists/arcsine/skewness":[],"@stdlib/stats/base/dists/arcsine/stdev":[],"@stdlib/stats/base/dists/arcsine/variance":[],"@stdlib/stats/base/dists/bernoulli/ctor":[],"@stdlib/stats/base/dists/bernoulli/cdf":[],"@stdlib/stats/base/dists/bernoulli/entropy":[],"@stdlib/stats/base/dists/bernoulli/kurtosis":[],"@stdlib/stats/base/dists/bernoulli/mean":[],"@stdlib/stats/base/dists/bernoulli/median":[],"@stdlib/stats/base/dists/bernoulli/mgf":[],"@stdlib/stats/base/dists/bernoulli/mode":[],"@stdlib/stats/base/dists/bernoulli/pmf":[],"@stdlib/stats/base/dists/bernoulli/quantile":[],"@stdlib/stats/base/dists/bernoulli/skewness":[],"@stdlib/stats/base/dists/bernoulli/stdev":[],"@stdlib/stats/base/dists/bernoulli/variance":[],"@stdlib/stats/base/dists/beta/ctor":[],"@stdlib/stats/base/dists/beta/cdf":[],"@stdlib/stats/base/dists/beta/entropy":[],"@stdlib/stats/base/dists/beta/kurtosis":[],"@stdlib/stats/base/dists/beta/logcdf":[],"@stdlib/stats/base/dists/beta/logpdf":[],"@stdlib/stats/base/dists/beta/mean":[],"@stdlib/stats/base/dists/beta/median":[],"@stdlib/stats/base/dists/beta/mgf":[],"@stdlib/stats/base/dists/beta/mode":[],"@stdlib/stats/base/dists/beta/pdf":[],"@stdlib/stats/base/dists/beta/quantile":[],"@stdlib/stats/base/dists/beta/skewness":[],"@stdlib/stats/base/dists/beta/stdev":[],"@stdlib/stats/base/dists/beta/variance":[],"@stdlib/stats/base/dists/betaprime/ctor":[],"@stdlib/stats/base/dists/betaprime/cdf":[],"@stdlib/stats/base/dists/betaprime/kurtosis":[],"@stdlib/stats/base/dists/betaprime/logcdf":[],"@stdlib/stats/base/dists/betaprime/logpdf":[],"@stdlib/stats/base/dists/betaprime/mean":[],"@stdlib/stats/base/dists/betaprime/mode":[],"@stdlib/stats/base/dists/betaprime/pdf":[],"@stdlib/stats/base/dists/betaprime/quantile":[],"@stdlib/stats/base/dists/betaprime/skewness":[],"@stdlib/stats/base/dists/betaprime/stdev":[],"@stdlib/stats/base/dists/betaprime/variance":[],"@stdlib/stats/base/dists/binomial/ctor":[],"@stdlib/stats/base/dists/binomial/cdf":[],"@stdlib/stats/base/dists/binomial/entropy":[],"@stdlib/stats/base/dists/binomial/kurtosis":[],"@stdlib/stats/base/dists/binomial/logpmf":[],"@stdlib/stats/base/dists/binomial/mean":[],"@stdlib/stats/base/dists/binomial/median":[],"@stdlib/stats/base/dists/binomial/mgf":[],"@stdlib/stats/base/dists/binomial/mode":[],"@stdlib/stats/base/dists/binomial/pmf":[],"@stdlib/stats/base/dists/binomial/quantile":[],"@stdlib/stats/base/dists/binomial/skewness":[],"@stdlib/stats/base/dists/binomial/stdev":[],"@stdlib/stats/base/dists/binomial/variance":[],"@stdlib/stats/base/dists/cauchy/ctor":[],"@stdlib/stats/base/dists/cauchy/cdf":[],"@stdlib/stats/base/dists/cauchy/entropy":[],"@stdlib/stats/base/dists/cauchy/logcdf":[],"@stdlib/stats/base/dists/cauchy/logpdf":[],"@stdlib/stats/base/dists/cauchy/median":[],"@stdlib/stats/base/dists/cauchy/mode":[],"@stdlib/stats/base/dists/cauchy/pdf":[],"@stdlib/stats/base/dists/cauchy/quantile":[],"@stdlib/stats/base/dists/chi/cdf":[],"@stdlib/stats/base/dists/chi/ctor":[],"@stdlib/stats/base/dists/chi/entropy":[],"@stdlib/stats/base/dists/chi/kurtosis":[],"@stdlib/stats/base/dists/chi/logpdf":[],"@stdlib/stats/base/dists/chi/mean":[],"@stdlib/stats/base/dists/chi/mode":[],"@stdlib/stats/base/dists/chi/pdf":[],"@stdlib/stats/base/dists/chi/quantile":[],"@stdlib/stats/base/dists/chi/skewness":[],"@stdlib/stats/base/dists/chi/stdev":[],"@stdlib/stats/base/dists/chi/variance":[],"@stdlib/stats/base/dists/chisquare/cdf":[],"@stdlib/stats/base/dists/chisquare/ctor":[],"@stdlib/stats/base/dists/chisquare/entropy":[],"@stdlib/stats/base/dists/chisquare/kurtosis":[],"@stdlib/stats/base/dists/chisquare/logpdf":[],"@stdlib/stats/base/dists/chisquare/mean":[],"@stdlib/stats/base/dists/chisquare/mgf":[],"@stdlib/stats/base/dists/chisquare/mode":[],"@stdlib/stats/base/dists/chisquare/pdf":[],"@stdlib/stats/base/dists/chisquare/quantile":[],"@stdlib/stats/base/dists/chisquare/skewness":[],"@stdlib/stats/base/dists/chisquare/stdev":[],"@stdlib/stats/base/dists/chisquare/variance":[],"@stdlib/stats/base/dists/cosine/cdf":[],"@stdlib/stats/base/dists/cosine/ctor":[],"@stdlib/stats/base/dists/cosine/kurtosis":[],"@stdlib/stats/base/dists/cosine/logcdf":[],"@stdlib/stats/base/dists/cosine/logpdf":[],"@stdlib/stats/base/dists/cosine/mean":[],"@stdlib/stats/base/dists/cosine/median":[],"@stdlib/stats/base/dists/cosine/mgf":[],"@stdlib/stats/base/dists/cosine/mode":[],"@stdlib/stats/base/dists/cosine/pdf":[],"@stdlib/stats/base/dists/cosine/quantile":[],"@stdlib/stats/base/dists/cosine/skewness":[],"@stdlib/stats/base/dists/cosine/stdev":[],"@stdlib/stats/base/dists/cosine/variance":[],"@stdlib/stats/base/dists/degenerate/cdf":[],"@stdlib/stats/base/dists/degenerate/ctor":[],"@stdlib/stats/base/dists/degenerate/entropy":[],"@stdlib/stats/base/dists/degenerate/logcdf":[],"@stdlib/stats/base/dists/degenerate/logpdf":[],"@stdlib/stats/base/dists/degenerate/logpmf":[],"@stdlib/stats/base/dists/degenerate/mean":[],"@stdlib/stats/base/dists/degenerate/median":[],"@stdlib/stats/base/dists/degenerate/mgf":[],"@stdlib/stats/base/dists/degenerate/mode":[],"@stdlib/stats/base/dists/degenerate/pdf":[],"@stdlib/stats/base/dists/degenerate/pmf":[],"@stdlib/stats/base/dists/degenerate/quantile":[],"@stdlib/stats/base/dists/degenerate/stdev":[],"@stdlib/stats/base/dists/degenerate/variance":[],"@stdlib/stats/base/dists/discrete-uniform/cdf":[],"@stdlib/stats/base/dists/discrete-uniform/ctor":[],"@stdlib/stats/base/dists/discrete-uniform/kurtosis":[],"@stdlib/stats/base/dists/discrete-uniform/logcdf":[],"@stdlib/stats/base/dists/discrete-uniform/logpmf":[],"@stdlib/stats/base/dists/discrete-uniform/mean":[],"@stdlib/stats/base/dists/discrete-uniform/median":[],"@stdlib/stats/base/dists/discrete-uniform/mgf":[],"@stdlib/stats/base/dists/discrete-uniform/pmf":[],"@stdlib/stats/base/dists/discrete-uniform/quantile":[],"@stdlib/stats/base/dists/discrete-uniform/skewness":[],"@stdlib/stats/base/dists/discrete-uniform/stdev":[],"@stdlib/stats/base/dists/discrete-uniform/variance":[],"@stdlib/stats/base/dists/erlang/cdf":[],"@stdlib/stats/base/dists/erlang/entropy":[],"@stdlib/stats/base/dists/erlang/ctor":[],"@stdlib/stats/base/dists/erlang/kurtosis":[],"@stdlib/stats/base/dists/erlang/logpdf":[],"@stdlib/stats/base/dists/erlang/mean":[],"@stdlib/stats/base/dists/erlang/mgf":[],"@stdlib/stats/base/dists/erlang/mode":[],"@stdlib/stats/base/dists/erlang/pdf":[],"@stdlib/stats/base/dists/erlang/quantile":[],"@stdlib/stats/base/dists/erlang/skewness":[],"@stdlib/stats/base/dists/erlang/stdev":[],"@stdlib/stats/base/dists/erlang/variance":[],"@stdlib/stats/base/dists/exponential/cdf":[],"@stdlib/stats/base/dists/exponential/entropy":[],"@stdlib/stats/base/dists/exponential/ctor":[],"@stdlib/stats/base/dists/exponential/kurtosis":[],"@stdlib/stats/base/dists/exponential/logcdf":[],"@stdlib/stats/base/dists/exponential/logpdf":[],"@stdlib/stats/base/dists/exponential/mean":[],"@stdlib/stats/base/dists/exponential/median":[],"@stdlib/stats/base/dists/exponential/mgf":[],"@stdlib/stats/base/dists/exponential/mode":[],"@stdlib/stats/base/dists/exponential/pdf":[],"@stdlib/stats/base/dists/exponential/quantile":[],"@stdlib/stats/base/dists/exponential/skewness":[],"@stdlib/stats/base/dists/exponential/stdev":[],"@stdlib/stats/base/dists/exponential/variance":[],"@stdlib/stats/base/dists/f/cdf":[],"@stdlib/stats/base/dists/f/entropy":[],"@stdlib/stats/base/dists/f/ctor":[],"@stdlib/stats/base/dists/f/kurtosis":[],"@stdlib/stats/base/dists/f/mean":[],"@stdlib/stats/base/dists/f/mode":[],"@stdlib/stats/base/dists/f/pdf":[],"@stdlib/stats/base/dists/f/quantile":[],"@stdlib/stats/base/dists/f/skewness":[],"@stdlib/stats/base/dists/f/stdev":[],"@stdlib/stats/base/dists/f/variance":[],"@stdlib/stats/base/dists/frechet/cdf":[],"@stdlib/stats/base/dists/frechet/entropy":[],"@stdlib/stats/base/dists/frechet/ctor":[],"@stdlib/stats/base/dists/frechet/kurtosis":[],"@stdlib/stats/base/dists/frechet/logcdf":[],"@stdlib/stats/base/dists/frechet/logpdf":[],"@stdlib/stats/base/dists/frechet/mean":[],"@stdlib/stats/base/dists/frechet/median":[],"@stdlib/stats/base/dists/frechet/mode":[],"@stdlib/stats/base/dists/frechet/pdf":[],"@stdlib/stats/base/dists/frechet/quantile":[],"@stdlib/stats/base/dists/frechet/skewness":[],"@stdlib/stats/base/dists/frechet/stdev":[],"@stdlib/stats/base/dists/frechet/variance":[],"@stdlib/stats/base/dists/gamma/cdf":[],"@stdlib/stats/base/dists/gamma/entropy":[],"@stdlib/stats/base/dists/gamma/ctor":[],"@stdlib/stats/base/dists/gamma/kurtosis":[],"@stdlib/stats/base/dists/gamma/logpdf":[],"@stdlib/stats/base/dists/gamma/mean":[],"@stdlib/stats/base/dists/gamma/mgf":[],"@stdlib/stats/base/dists/gamma/mode":[],"@stdlib/stats/base/dists/gamma/pdf":[],"@stdlib/stats/base/dists/gamma/quantile":[],"@stdlib/stats/base/dists/gamma/skewness":[],"@stdlib/stats/base/dists/gamma/stdev":[],"@stdlib/stats/base/dists/gamma/variance":[],"@stdlib/stats/base/dists/geometric/cdf":[],"@stdlib/stats/base/dists/geometric/entropy":[],"@stdlib/stats/base/dists/geometric/ctor":[],"@stdlib/stats/base/dists/geometric/kurtosis":[],"@stdlib/stats/base/dists/geometric/logcdf":[],"@stdlib/stats/base/dists/geometric/logpmf":[],"@stdlib/stats/base/dists/geometric/mean":[],"@stdlib/stats/base/dists/geometric/median":[],"@stdlib/stats/base/dists/geometric/mgf":[],"@stdlib/stats/base/dists/geometric/mode":[],"@stdlib/stats/base/dists/geometric/pmf":[],"@stdlib/stats/base/dists/geometric/quantile":[],"@stdlib/stats/base/dists/geometric/skewness":[],"@stdlib/stats/base/dists/geometric/stdev":[],"@stdlib/stats/base/dists/geometric/variance":[],"@stdlib/stats/base/dists/gumbel/cdf":[],"@stdlib/stats/base/dists/gumbel/entropy":[],"@stdlib/stats/base/dists/gumbel/ctor":[],"@stdlib/stats/base/dists/gumbel/kurtosis":[],"@stdlib/stats/base/dists/gumbel/logcdf":[],"@stdlib/stats/base/dists/gumbel/logpdf":[],"@stdlib/stats/base/dists/gumbel/mean":[],"@stdlib/stats/base/dists/gumbel/median":[],"@stdlib/stats/base/dists/gumbel/mgf":[],"@stdlib/stats/base/dists/gumbel/mode":[],"@stdlib/stats/base/dists/gumbel/pdf":[],"@stdlib/stats/base/dists/gumbel/quantile":[],"@stdlib/stats/base/dists/gumbel/skewness":[],"@stdlib/stats/base/dists/gumbel/stdev":[],"@stdlib/stats/base/dists/gumbel/variance":[],"@stdlib/stats/base/dists/hypergeometric/cdf":[],"@stdlib/stats/base/dists/hypergeometric/ctor":[],"@stdlib/stats/base/dists/hypergeometric/kurtosis":[],"@stdlib/stats/base/dists/hypergeometric/logpmf":[],"@stdlib/stats/base/dists/hypergeometric/mean":[],"@stdlib/stats/base/dists/hypergeometric/mode":[],"@stdlib/stats/base/dists/hypergeometric/pmf":[],"@stdlib/stats/base/dists/hypergeometric/quantile":[],"@stdlib/stats/base/dists/hypergeometric/skewness":[],"@stdlib/stats/base/dists/hypergeometric/stdev":[],"@stdlib/stats/base/dists/hypergeometric/variance":[],"@stdlib/stats/base/dists/invgamma/cdf":[],"@stdlib/stats/base/dists/invgamma/entropy":[],"@stdlib/stats/base/dists/invgamma/ctor":[],"@stdlib/stats/base/dists/invgamma/kurtosis":[],"@stdlib/stats/base/dists/invgamma/logpdf":[],"@stdlib/stats/base/dists/invgamma/mean":[],"@stdlib/stats/base/dists/invgamma/mode":[],"@stdlib/stats/base/dists/invgamma/pdf":[],"@stdlib/stats/base/dists/invgamma/quantile":[],"@stdlib/stats/base/dists/invgamma/skewness":[],"@stdlib/stats/base/dists/invgamma/stdev":[],"@stdlib/stats/base/dists/invgamma/variance":[],"@stdlib/stats/base/dists/kumaraswamy/cdf":[],"@stdlib/stats/base/dists/kumaraswamy/ctor":[],"@stdlib/stats/base/dists/kumaraswamy/kurtosis":[],"@stdlib/stats/base/dists/kumaraswamy/logcdf":[],"@stdlib/stats/base/dists/kumaraswamy/logpdf":[],"@stdlib/stats/base/dists/kumaraswamy/mean":[],"@stdlib/stats/base/dists/kumaraswamy/median":[],"@stdlib/stats/base/dists/kumaraswamy/mode":[],"@stdlib/stats/base/dists/kumaraswamy/pdf":[],"@stdlib/stats/base/dists/kumaraswamy/quantile":[],"@stdlib/stats/base/dists/kumaraswamy/skewness":[],"@stdlib/stats/base/dists/kumaraswamy/stdev":[],"@stdlib/stats/base/dists/kumaraswamy/variance":[],"@stdlib/stats/base/dists/laplace/cdf":[],"@stdlib/stats/base/dists/laplace/entropy":[],"@stdlib/stats/base/dists/laplace/kurtosis":[],"@stdlib/stats/base/dists/laplace/ctor":[],"@stdlib/stats/base/dists/laplace/logcdf":[],"@stdlib/stats/base/dists/laplace/logpdf":[],"@stdlib/stats/base/dists/laplace/mean":[],"@stdlib/stats/base/dists/laplace/median":[],"@stdlib/stats/base/dists/laplace/mgf":[],"@stdlib/stats/base/dists/laplace/mode":[],"@stdlib/stats/base/dists/laplace/pdf":[],"@stdlib/stats/base/dists/laplace/quantile":[],"@stdlib/stats/base/dists/laplace/skewness":[],"@stdlib/stats/base/dists/laplace/stdev":[],"@stdlib/stats/base/dists/laplace/variance":[],"@stdlib/stats/base/dists/levy/cdf":[],"@stdlib/stats/base/dists/levy/entropy":[],"@stdlib/stats/base/dists/levy/ctor":[],"@stdlib/stats/base/dists/levy/logcdf":[],"@stdlib/stats/base/dists/levy/logpdf":[],"@stdlib/stats/base/dists/levy/mean":[],"@stdlib/stats/base/dists/levy/median":[],"@stdlib/stats/base/dists/levy/mode":[],"@stdlib/stats/base/dists/levy/pdf":[],"@stdlib/stats/base/dists/levy/quantile":[],"@stdlib/stats/base/dists/levy/stdev":[],"@stdlib/stats/base/dists/levy/variance":[],"@stdlib/stats/base/dists/logistic/cdf":[],"@stdlib/stats/base/dists/logistic/entropy":[],"@stdlib/stats/base/dists/logistic/kurtosis":[],"@stdlib/stats/base/dists/logistic/logcdf":[],"@stdlib/stats/base/dists/logistic/ctor":[],"@stdlib/stats/base/dists/logistic/logpdf":[],"@stdlib/stats/base/dists/logistic/mean":[],"@stdlib/stats/base/dists/logistic/median":[],"@stdlib/stats/base/dists/logistic/mgf":[],"@stdlib/stats/base/dists/logistic/mode":[],"@stdlib/stats/base/dists/logistic/pdf":[],"@stdlib/stats/base/dists/logistic/quantile":[],"@stdlib/stats/base/dists/logistic/skewness":[],"@stdlib/stats/base/dists/logistic/stdev":[],"@stdlib/stats/base/dists/logistic/variance":[],"@stdlib/stats/base/dists/lognormal/cdf":[],"@stdlib/stats/base/dists/lognormal/entropy":[],"@stdlib/stats/base/dists/lognormal/kurtosis":[],"@stdlib/stats/base/dists/lognormal/ctor":[],"@stdlib/stats/base/dists/lognormal/logpdf":[],"@stdlib/stats/base/dists/lognormal/mean":[],"@stdlib/stats/base/dists/lognormal/median":[],"@stdlib/stats/base/dists/lognormal/mode":[],"@stdlib/stats/base/dists/lognormal/pdf":[],"@stdlib/stats/base/dists/lognormal/quantile":[],"@stdlib/stats/base/dists/lognormal/skewness":[],"@stdlib/stats/base/dists/lognormal/stdev":[],"@stdlib/stats/base/dists/lognormal/variance":[],"@stdlib/stats/base/dists/negative-binomial/cdf":[],"@stdlib/stats/base/dists/negative-binomial/kurtosis":[],"@stdlib/stats/base/dists/negative-binomial/logpmf":[],"@stdlib/stats/base/dists/negative-binomial/mean":[],"@stdlib/stats/base/dists/negative-binomial/mgf":[],"@stdlib/stats/base/dists/negative-binomial/mode":[],"@stdlib/stats/base/dists/negative-binomial/ctor":[],"@stdlib/stats/base/dists/negative-binomial/pmf":[],"@stdlib/stats/base/dists/negative-binomial/quantile":[],"@stdlib/stats/base/dists/negative-binomial/skewness":[],"@stdlib/stats/base/dists/negative-binomial/stdev":[],"@stdlib/stats/base/dists/negative-binomial/variance":[],"@stdlib/stats/base/dists/normal/cdf":[],"@stdlib/stats/base/dists/normal/entropy":[],"@stdlib/stats/base/dists/normal/kurtosis":[],"@stdlib/stats/base/dists/normal/logpdf":[],"@stdlib/stats/base/dists/normal/mean":[],"@stdlib/stats/base/dists/normal/median":[],"@stdlib/stats/base/dists/normal/mgf":[],"@stdlib/stats/base/dists/normal/mode":[],"@stdlib/stats/base/dists/normal/ctor":[],"@stdlib/stats/base/dists/normal/pdf":[],"@stdlib/stats/base/dists/normal/quantile":[],"@stdlib/stats/base/dists/normal/skewness":[],"@stdlib/stats/base/dists/normal/stdev":[],"@stdlib/stats/base/dists/normal/variance":[],"@stdlib/stats/base/dists/pareto-type1/cdf":[],"@stdlib/stats/base/dists/pareto-type1/entropy":[],"@stdlib/stats/base/dists/pareto-type1/kurtosis":[],"@stdlib/stats/base/dists/pareto-type1/logcdf":[],"@stdlib/stats/base/dists/pareto-type1/logpdf":[],"@stdlib/stats/base/dists/pareto-type1/mean":[],"@stdlib/stats/base/dists/pareto-type1/median":[],"@stdlib/stats/base/dists/pareto-type1/mode":[],"@stdlib/stats/base/dists/pareto-type1/ctor":[],"@stdlib/stats/base/dists/pareto-type1/pdf":[],"@stdlib/stats/base/dists/pareto-type1/quantile":[],"@stdlib/stats/base/dists/pareto-type1/skewness":[],"@stdlib/stats/base/dists/pareto-type1/variance":[],"@stdlib/stats/base/dists/poisson/cdf":[],"@stdlib/stats/base/dists/poisson/entropy":[],"@stdlib/stats/base/dists/poisson/kurtosis":[],"@stdlib/stats/base/dists/poisson/logpmf":[],"@stdlib/stats/base/dists/poisson/mean":[],"@stdlib/stats/base/dists/poisson/median":[],"@stdlib/stats/base/dists/poisson/mgf":[],"@stdlib/stats/base/dists/poisson/mode":[],"@stdlib/stats/base/dists/poisson/pmf":[],"@stdlib/stats/base/dists/poisson/ctor":[],"@stdlib/stats/base/dists/poisson/quantile":[],"@stdlib/stats/base/dists/poisson/skewness":[],"@stdlib/stats/base/dists/poisson/stdev":[],"@stdlib/stats/base/dists/poisson/variance":[],"@stdlib/stats/base/dists/rayleigh/cdf":[],"@stdlib/stats/base/dists/rayleigh/entropy":[],"@stdlib/stats/base/dists/rayleigh/kurtosis":[],"@stdlib/stats/base/dists/rayleigh/logcdf":[],"@stdlib/stats/base/dists/rayleigh/logpdf":[],"@stdlib/stats/base/dists/rayleigh/mean":[],"@stdlib/stats/base/dists/rayleigh/median":[],"@stdlib/stats/base/dists/rayleigh/mgf":[],"@stdlib/stats/base/dists/rayleigh/mode":[],"@stdlib/stats/base/dists/rayleigh/pdf":[],"@stdlib/stats/base/dists/rayleigh/quantile":[],"@stdlib/stats/base/dists/rayleigh/ctor":[],"@stdlib/stats/base/dists/rayleigh/skewness":[],"@stdlib/stats/base/dists/rayleigh/stdev":[],"@stdlib/stats/base/dists/rayleigh/variance":[],"@stdlib/stats/base/dists/t/cdf":[],"@stdlib/stats/base/dists/t/entropy":[],"@stdlib/stats/base/dists/t/kurtosis":[],"@stdlib/stats/base/dists/t/mean":[],"@stdlib/stats/base/dists/t/median":[],"@stdlib/stats/base/dists/t/mode":[],"@stdlib/stats/base/dists/t/pdf":[],"@stdlib/stats/base/dists/t/quantile":[],"@stdlib/stats/base/dists/t/skewness":[],"@stdlib/stats/base/dists/t/stdev":[],"@stdlib/stats/base/dists/t/ctor":[],"@stdlib/stats/base/dists/t/variance":[],"@stdlib/stats/base/dists/triangular/cdf":[],"@stdlib/stats/base/dists/triangular/entropy":[],"@stdlib/stats/base/dists/triangular/kurtosis":[],"@stdlib/stats/base/dists/triangular/logcdf":[],"@stdlib/stats/base/dists/triangular/logpdf":[],"@stdlib/stats/base/dists/triangular/mean":[],"@stdlib/stats/base/dists/triangular/median":[],"@stdlib/stats/base/dists/triangular/mgf":[],"@stdlib/stats/base/dists/triangular/mode":[],"@stdlib/stats/base/dists/triangular/pdf":[],"@stdlib/stats/base/dists/triangular/quantile":[],"@stdlib/stats/base/dists/triangular/skewness":[],"@stdlib/stats/base/dists/triangular/stdev":[],"@stdlib/stats/base/dists/triangular/ctor":[],"@stdlib/stats/base/dists/triangular/variance":[],"@stdlib/stats/base/dists/uniform/cdf":[],"@stdlib/stats/base/dists/uniform/entropy":[],"@stdlib/stats/base/dists/uniform/kurtosis":[],"@stdlib/stats/base/dists/uniform/logcdf":[],"@stdlib/stats/base/dists/uniform/logpdf":[],"@stdlib/stats/base/dists/uniform/mean":[],"@stdlib/stats/base/dists/uniform/median":[],"@stdlib/stats/base/dists/uniform/mgf":[],"@stdlib/stats/base/dists/uniform/pdf":[],"@stdlib/stats/base/dists/uniform/quantile":[],"@stdlib/stats/base/dists/uniform/skewness":[],"@stdlib/stats/base/dists/uniform/stdev":[],"@stdlib/stats/base/dists/uniform/ctor":[],"@stdlib/stats/base/dists/uniform/variance":[],"@stdlib/stats/base/dists/weibull/cdf":[],"@stdlib/stats/base/dists/weibull/entropy":[],"@stdlib/stats/base/dists/weibull/kurtosis":[],"@stdlib/stats/base/dists/weibull/logcdf":[],"@stdlib/stats/base/dists/weibull/logpdf":[],"@stdlib/stats/base/dists/weibull/mean":[],"@stdlib/stats/base/dists/weibull/median":[],"@stdlib/stats/base/dists/weibull/mgf":[],"@stdlib/stats/base/dists/weibull/mode":[],"@stdlib/stats/base/dists/weibull/pdf":[],"@stdlib/stats/base/dists/weibull/quantile":[],"@stdlib/stats/base/dists/weibull/skewness":[],"@stdlib/stats/base/dists/weibull/stdev":[],"@stdlib/stats/base/dists/weibull/variance":[],"@stdlib/stats/base/dists/weibull/ctor":[],"@stdlib/math/base/special/ellipe":["@stdlib/math/base/special/ellipk"],"@stdlib/math/base/special/ellipk":["@stdlib/math/base/special/ellipe"],"@stdlib/math/base/utils/float64-epsilon-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/relative-difference"],"@stdlib/math/base/special/erf":["@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/erfc":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfinv","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/erfcinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfinv"],"@stdlib/math/base/special/erfinv":["@stdlib/math/base/special/erf","@stdlib/math/base/special/erfc","@stdlib/math/base/special/erfcinv"],"@stdlib/math/base/special/dirichlet-eta":[],"@stdlib/math/base/tools/evalpoly":["@stdlib/math/base/tools/evalrational"],"@stdlib/math/base/tools/evalrational":["@stdlib/math/base/tools/evalpoly"],"@stdlib/math/base/special/exp":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/exp2","@stdlib/math/base/special/expm1","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/exp2":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp10"],"@stdlib/math/base/special/exp10":["@stdlib/math/base/special/exp","@stdlib/math/base/special/exp2"],"@stdlib/math/base/special/expit":["@stdlib/math/base/special/exp","@stdlib/math/base/special/logit"],"@stdlib/math/base/special/expm1":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1rel"],"@stdlib/math/base/special/expm1rel":["@stdlib/math/base/special/exp","@stdlib/math/base/special/expm1"],"@stdlib/number/float64/base/exponent":["@stdlib/number/float32/base/exponent"],"@stdlib/number/float32/base/exponent":["@stdlib/number/float64/base/exponent"],"@stdlib/math/base/special/factorial":["@stdlib/math/base/special/factorialln"],"@stdlib/math/base/special/factorialln":["@stdlib/math/base/special/factorial"],"@stdlib/math/base/special/falling-factorial":["@stdlib/math/base/special/rising-factorial"],"@stdlib/math/base/special/fibonacci":["@stdlib/math/base/special/binet","@stdlib/math/base/special/fibonacci-index","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/fibonacci-index":["@stdlib/math/base/special/fibonacci"],"@stdlib/math/base/tools/fibpoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/lucaspoly"],"@stdlib/math/base/special/flipsign":["@stdlib/math/base/special/copysign"],"@stdlib/number/float32/base/to-int32":["@stdlib/number/float32/base/to-uint32"],"@stdlib/number/float32/base/to-uint32":["@stdlib/number/float32/base/to-int32"],"@stdlib/number/float64/base/to-float32":[],"@stdlib/number/float64/base/to-int32":["@stdlib/number/float64/base/to-uint32"],"@stdlib/number/float64/base/to-uint32":["@stdlib/number/float64/base/to-int32"],"@stdlib/math/base/special/floor":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/round"],"@stdlib/math/base/special/floor2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/floor10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/floorb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/floorn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floor","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/floorsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/fresnel":["@stdlib/math/base/special/fresnelc","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnelc":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnels"],"@stdlib/math/base/special/fresnels":["@stdlib/math/base/special/fresnel","@stdlib/math/base/special/fresnelc"],"@stdlib/math/base/special/frexp":["@stdlib/math/base/special/ldexp"],"@stdlib/number/float64/base/from-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/from-binary-string":["@stdlib/number/float32/base/to-binary-string","@stdlib/number/float64/base/from-binary-string"],"@stdlib/number/uint8/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/to-binary-string"],"@stdlib/number/uint16/base/from-binary-string":["@stdlib/number/uint16/base/to-binary-string","@stdlib/number/uint32/base/from-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/uint32/base/from-binary-string":["@stdlib/number/uint16/base/from-binary-string","@stdlib/number/uint32/base/to-binary-string","@stdlib/number/uint8/base/from-binary-string"],"@stdlib/number/float32/base/from-word":["@stdlib/number/float64/base/from-words"],"@stdlib/number/float64/base/from-words":["@stdlib/number/float32/base/from-word"],"@stdlib/math/base/special/gamma":["@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma1pm1":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-delta-ratio":["@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/gammainc":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammaincinv","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gammaincinv":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma1pm1","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaln"],"@stdlib/math/base/special/gamma-lanczos-sum":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled"],"@stdlib/math/base/special/gamma-lanczos-sum-expg-scaled":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gamma-lanczos-sum"],"@stdlib/math/base/special/gammaln":["@stdlib/math/base/special/gamma","@stdlib/math/base/special/gammainc","@stdlib/math/base/special/gammaincinv"],"@stdlib/blas/base/gasum":["@stdlib/blas/base/dasum","@stdlib/blas/base/sasum"],"@stdlib/blas/base/gaxpy":["@stdlib/blas/base/daxpy","@stdlib/blas/base/saxpy"],"@stdlib/math/base/special/gcd":["@stdlib/math/base/special/lcm"],"@stdlib/blas/base/gcopy":["@stdlib/blas/base/dcopy"],"@stdlib/number/float64/base/get-high-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/number/float64/base/get-low-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/hacovercos":["@stdlib/math/base/special/hacoversin","@stdlib/math/base/special/havercos"],"@stdlib/math/base/special/hacoversin":["@stdlib/math/base/special/hacovercos","@stdlib/math/base/special/haversin"],"@stdlib/math/base/special/havercos":["@stdlib/math/base/special/haversin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/haversin":["@stdlib/math/base/special/havercos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/heaviside":["@stdlib/math/base/special/ramp"],"@stdlib/math/base/tools/hermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/normhermitepoly"],"@stdlib/math/base/special/hypot":[],"@stdlib/math/base/special/imul":["@stdlib/math/base/special/imuldw","@stdlib/math/base/special/uimul"],"@stdlib/math/base/special/imuldw":["@stdlib/math/base/special/imul","@stdlib/math/base/special/uimuldw"],"@stdlib/number/int32/base/to-uint32":["@stdlib/number/uint32/base/to-int32"],"@stdlib/math/base/special/inv":["@stdlib/math/base/special/pow"],"@stdlib/math/base/assert/is-even":["@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/int32-is-even":["@stdlib/math/base/assert/is-even","@stdlib/math/base/assert/int32-is-odd"],"@stdlib/math/base/assert/is-finite":["@stdlib/math/base/assert/is-infinite"],"@stdlib/math/base/assert/is-infinite":["@stdlib/math/base/assert/is-finite"],"@stdlib/math/base/assert/is-integer":[],"@stdlib/math/base/assert/is-nan":[],"@stdlib/math/base/assert/is-negative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-negative-zero":["@stdlib/math/base/assert/is-positive-zero"],"@stdlib/math/base/assert/is-nonnegative-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonpositive-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-nonpositive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-positive-integer"],"@stdlib/math/base/assert/is-odd":["@stdlib/math/base/assert/is-even"],"@stdlib/math/base/assert/int32-is-odd":["@stdlib/math/base/assert/int32-is-even","@stdlib/math/base/assert/is-odd"],"@stdlib/math/base/assert/is-positive-integer":["@stdlib/math/base/assert/is-integer","@stdlib/math/base/assert/is-negative-integer","@stdlib/math/base/assert/is-nonnegative-integer","@stdlib/math/base/assert/is-nonpositive-integer"],"@stdlib/math/base/assert/is-positive-zero":["@stdlib/math/base/assert/is-negative-zero"],"@stdlib/math/base/assert/uint32-is-pow2":[],"@stdlib/math/base/assert/is-probability":[],"@stdlib/math/base/assert/is-safe-integer":[],"@stdlib/math/base/special/kernel-betainc":["@stdlib/math/base/special/betainc"],"@stdlib/math/base/special/kernel-betaincinv":["@stdlib/math/base/special/betaincinv"],"@stdlib/math/base/special/kernel-cos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/kernel-tan"],"@stdlib/math/base/special/kernel-sin":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-tan","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/kernel-tan":["@stdlib/math/base/special/kernel-cos","@stdlib/math/base/special/kernel-sin","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/kronecker-delta":["@stdlib/math/base/special/dirac-delta"],"@stdlib/math/base/special/lcm":["@stdlib/math/base/special/gcd"],"@stdlib/math/base/special/ldexp":["@stdlib/math/base/special/frexp"],"@stdlib/math/base/special/ln":["@stdlib/math/base/special/exp","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log10","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log2"],"@stdlib/math/base/special/log1mexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1p","@stdlib/math/base/special/log1pexp"],"@stdlib/math/base/special/log1p":["@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log1pexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln","@stdlib/math/base/special/log1mexp","@stdlib/math/base/special/log1p"],"@stdlib/math/base/special/log2":["@stdlib/math/base/special/exp2","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/log10":["@stdlib/math/base/special/exp10","@stdlib/math/base/special/ln","@stdlib/math/base/special/log"],"@stdlib/math/base/special/logaddexp":["@stdlib/math/base/special/exp","@stdlib/math/base/special/ln"],"@stdlib/math/base/special/logit":[],"@stdlib/math/base/special/lucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/tools/lucaspoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/fibpoly"],"@stdlib/math/base/special/max":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/min"],"@stdlib/math/base/special/maxabs":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/min":["@stdlib/math/base/special/max","@stdlib/math/base/special/minabs"],"@stdlib/math/base/special/minabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/min"],"@stdlib/math/base/special/minmax":["@stdlib/math/base/special/max","@stdlib/math/base/special/min","@stdlib/math/base/special/minmaxabs"],"@stdlib/math/base/special/minmaxabs":["@stdlib/math/base/special/maxabs","@stdlib/math/base/special/minabs","@stdlib/math/base/special/minmax"],"@stdlib/math/base/special/modf":[],"@stdlib/ndarray/base/ctor":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/base/memoized-ctor":["@stdlib/ndarray/array","@stdlib/ndarray/base/ctor","@stdlib/ndarray/ctor","@stdlib/ndarray/memoized-ctor"],"@stdlib/math/base/special/negafibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/negalucas"],"@stdlib/math/base/special/negalucas":["@stdlib/math/base/special/fibonacci","@stdlib/math/base/special/lucas","@stdlib/math/base/special/negafibonacci"],"@stdlib/math/base/special/nonfibonacci":["@stdlib/math/base/special/fibonacci"],"@stdlib/number/float64/base/normalize":["@stdlib/number/float32/base/normalize"],"@stdlib/number/float32/base/normalize":["@stdlib/number/float64/base/normalize"],"@stdlib/math/base/tools/normhermitepoly":["@stdlib/math/base/tools/evalpoly","@stdlib/math/base/tools/hermitepoly"],"@stdlib/math/base/special/pdiff":[],"@stdlib/math/base/special/polygamma":["@stdlib/math/base/special/trigamma","@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/pow":["@stdlib/math/base/special/exp","@stdlib/math/base/special/powm1"],"@stdlib/math/base/special/powm1":["@stdlib/math/base/special/pow"],"@stdlib/math/base/special/rad2deg":["@stdlib/math/base/special/deg2rad"],"@stdlib/math/base/special/ramp":["@stdlib/math/base/special/heaviside"],"@stdlib/random/base/arcsine":["@stdlib/random/base/beta"],"@stdlib/random/base/bernoulli":["@stdlib/random/base/binomial"],"@stdlib/random/base/beta":[],"@stdlib/random/base/betaprime":[],"@stdlib/random/base/binomial":[],"@stdlib/random/base/box-muller":[],"@stdlib/random/base/cauchy":[],"@stdlib/random/base/chi":[],"@stdlib/random/base/chisquare":[],"@stdlib/random/base/cosine":[],"@stdlib/random/base/discrete-uniform":[],"@stdlib/random/base/erlang":[],"@stdlib/random/base/exponential":[],"@stdlib/random/base/f":[],"@stdlib/random/base/frechet":[],"@stdlib/random/base/gamma":[],"@stdlib/random/base/geometric":[],"@stdlib/random/base/gumbel":[],"@stdlib/random/base/hypergeometric":[],"@stdlib/random/base/improved-ziggurat":[],"@stdlib/random/base/invgamma":[],"@stdlib/random/base/kumaraswamy":[],"@stdlib/random/base/laplace":[],"@stdlib/random/base/levy":[],"@stdlib/random/base/logistic":[],"@stdlib/random/base/lognormal":[],"@stdlib/random/base/minstd":["@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/minstd-shuffle":["@stdlib/random/base/minstd","@stdlib/random/base/mt19937","@stdlib/random/base/randi"],"@stdlib/random/base/mt19937":["@stdlib/random/base/minstd","@stdlib/random/base/randi"],"@stdlib/random/base/negative-binomial":[],"@stdlib/random/base/normal":[],"@stdlib/random/base/pareto-type1":[],"@stdlib/random/base/poisson":[],"@stdlib/random/base/randi":["@stdlib/random/base/minstd","@stdlib/random/base/minstd-shuffle","@stdlib/random/base/mt19937"],"@stdlib/random/base/randn":["@stdlib/random/base/improved-ziggurat","@stdlib/random/base/randu"],"@stdlib/random/base/randu":["@stdlib/random/base/discrete-uniform","@stdlib/random/base/randn"],"@stdlib/random/base/rayleigh":[],"@stdlib/random/base/t":[],"@stdlib/random/base/triangular":[],"@stdlib/random/base/uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/base/randu"],"@stdlib/random/base/weibull":[],"@stdlib/math/base/utils/relative-difference":["@stdlib/math/base/utils/absolute-difference","@stdlib/math/base/utils/float64-epsilon-difference"],"@stdlib/math/base/special/rempio2":[],"@stdlib/math/base/special/rising-factorial":["@stdlib/math/base/special/falling-factorial"],"@stdlib/number/uint32/base/rotl":["@stdlib/number/uint32/base/rotr"],"@stdlib/number/uint32/base/rotr":["@stdlib/number/uint32/base/rotl"],"@stdlib/math/base/special/round":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/round2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round","@stdlib/math/base/special/round10"],"@stdlib/math/base/special/round10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round","@stdlib/math/base/special/round2"],"@stdlib/math/base/special/roundb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/round","@stdlib/math/base/special/roundn"],"@stdlib/math/base/special/roundn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/round","@stdlib/math/base/special/roundb"],"@stdlib/math/base/special/roundsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/round","@stdlib/math/base/special/truncsd"],"@stdlib/math/base/special/rsqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/blas/base/sasum":["@stdlib/blas/base/dasum"],"@stdlib/blas/base/saxpy":["@stdlib/blas/base/daxpy"],"@stdlib/blas/base/scopy":["@stdlib/blas/base/dcopy"],"@stdlib/number/float64/base/set-high-word":["@stdlib/number/float64/base/get-high-word","@stdlib/number/float64/base/set-low-word"],"@stdlib/number/float64/base/set-low-word":["@stdlib/number/float64/base/get-low-word","@stdlib/number/float64/base/set-high-word"],"@stdlib/math/base/special/sici":[],"@stdlib/number/float64/base/signbit":["@stdlib/number/float32/base/signbit"],"@stdlib/number/float32/base/signbit":["@stdlib/number/float64/base/signbit"],"@stdlib/number/float32/base/significand":[],"@stdlib/math/base/special/signum":[],"@stdlib/math/base/special/sin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sinpi","@stdlib/math/base/special/tan"],"@stdlib/math/base/special/sinc":["@stdlib/math/base/special/sin"],"@stdlib/math/base/special/sincos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/sincospi"],"@stdlib/math/base/special/sincospi":["@stdlib/math/base/special/cospi","@stdlib/math/base/special/sincos","@stdlib/math/base/special/sinpi"],"@stdlib/math/base/special/sinh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sin","@stdlib/math/base/special/tanh"],"@stdlib/math/base/special/sinpi":["@stdlib/math/base/special/sin"],"@stdlib/math/base/special/spence":[],"@stdlib/math/base/special/sqrt":["@stdlib/math/base/special/cbrt","@stdlib/math/base/special/rsqrt"],"@stdlib/math/base/special/sqrt1pm1":["@stdlib/math/base/special/sqrt"],"@stdlib/math/base/tools/sum-series":[],"@stdlib/math/base/special/tan":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin"],"@stdlib/math/base/special/tanh":["@stdlib/math/base/special/cosh","@stdlib/math/base/special/sinh","@stdlib/math/base/special/tan"],"@stdlib/number/float64/base/to-binary-string":["@stdlib/number/float64/base/from-binary-string","@stdlib/number/float32/base/to-binary-string"],"@stdlib/number/float32/base/to-binary-string":["@stdlib/number/float32/base/from-binary-string","@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint8/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint16/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/uint32/base/to-binary-string":["@stdlib/number/float64/base/to-binary-string"],"@stdlib/number/float32/base/to-word":["@stdlib/number/float32/base/from-word","@stdlib/number/float64/base/to-words"],"@stdlib/number/float64/base/to-words":["@stdlib/number/float64/base/from-words","@stdlib/number/float32/base/to-word"],"@stdlib/math/base/special/trigamma":["@stdlib/math/base/special/digamma","@stdlib/math/base/special/gamma"],"@stdlib/math/base/special/trunc":["@stdlib/math/base/special/ceil","@stdlib/math/base/special/floor","@stdlib/math/base/special/round"],"@stdlib/math/base/special/trunc2":["@stdlib/math/base/special/ceil2","@stdlib/math/base/special/floor2","@stdlib/math/base/special/round2","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc10"],"@stdlib/math/base/special/trunc10":["@stdlib/math/base/special/ceil10","@stdlib/math/base/special/floor10","@stdlib/math/base/special/round10","@stdlib/math/base/special/trunc","@stdlib/math/base/special/trunc2"],"@stdlib/math/base/special/truncb":["@stdlib/math/base/special/ceilb","@stdlib/math/base/special/floorb","@stdlib/math/base/special/roundb","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncn"],"@stdlib/math/base/special/truncn":["@stdlib/math/base/special/ceiln","@stdlib/math/base/special/floorn","@stdlib/math/base/special/roundn","@stdlib/math/base/special/trunc","@stdlib/math/base/special/truncb"],"@stdlib/math/base/special/truncsd":["@stdlib/math/base/special/ceilsd","@stdlib/math/base/special/floorsd","@stdlib/math/base/special/roundsd","@stdlib/math/base/special/trunc"],"@stdlib/math/base/special/uimul":["@stdlib/math/base/special/imul"],"@stdlib/math/base/special/uimuldw":["@stdlib/math/base/special/imuldw","@stdlib/math/base/special/uimul"],"@stdlib/number/uint32/base/to-int32":[],"@stdlib/math/base/special/vercos":["@stdlib/math/base/special/cos","@stdlib/math/base/special/versin"],"@stdlib/math/base/special/versin":["@stdlib/math/base/special/cos","@stdlib/math/base/special/sin","@stdlib/math/base/special/vercos"],"@stdlib/math/base/special/wrap":["@stdlib/math/base/special/clamp"],"@stdlib/math/base/special/xlog1py":["@stdlib/math/base/special/log1p","@stdlib/math/base/special/xlogy"],"@stdlib/math/base/special/xlogy":["@stdlib/math/base/special/ln","@stdlib/math/base/special/xlog1py"],"@stdlib/math/base/special/riemann-zeta":[],"@stdlib/datasets/berndt-cps-wages-1985":[],"@stdlib/utils/bifurcate":["@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group"],"@stdlib/utils/bifurcate-by":["@stdlib/utils/bifurcate","@stdlib/utils/group-by"],"@stdlib/utils/async/bifurcate-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/async/group-by"],"@stdlib/utils/bifurcate-in":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-own","@stdlib/utils/group-in"],"@stdlib/utils/bifurcate-own":["@stdlib/utils/bifurcate","@stdlib/utils/bifurcate-by","@stdlib/utils/bifurcate-in","@stdlib/utils/group-own"],"@stdlib/stats/binomial-test":[],"@stdlib/buffer/ctor":["@stdlib/array/buffer"],"@stdlib/buffer/to-json":["@stdlib/array/to-json","@stdlib/buffer/reviver"],"@stdlib/string/capitalize":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/capitalize-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/constants/math/float64-catalan":[],"@stdlib/constants/math/float64-cbrt-eps":["@stdlib/constants/math/float64-eps","@stdlib/constants/math/float64-sqrt-eps"],"@stdlib/process/chdir":["@stdlib/process/cwd"],"@stdlib/stats/chi2gof":[],"@stdlib/array/to-circular-iterator":["@stdlib/array/to-iterator","@stdlib/array/to-strided-iterator"],"@stdlib/streams/node/from-circular-array":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator","@stdlib/streams/node/from-strided-array"],"@stdlib/utils/circular-buffer":["@stdlib/utils/fifo","@stdlib/utils/stack"],"@stdlib/datasets/cmudict":[],"@stdlib/complex/cmplx":["@stdlib/complex/float64","@stdlib/complex/float32"],"@stdlib/complex/float32":["@stdlib/complex/cmplx","@stdlib/complex/float64"],"@stdlib/constants/math/complex64-num-bytes":["@stdlib/constants/math/complex128-num-bytes","@stdlib/constants/math/float32-num-bytes"],"@stdlib/array/complex64":["@stdlib/array/complex128","@stdlib/complex/cmplx","@stdlib/complex/float32"],"@stdlib/complex/float64":["@stdlib/complex/cmplx","@stdlib/complex/float32"],"@stdlib/constants/math/complex128-num-bytes":["@stdlib/constants/math/complex64-num-bytes","@stdlib/constants/math/float64-num-bytes"],"@stdlib/array/complex128":["@stdlib/array/complex64","@stdlib/complex/cmplx","@stdlib/complex/float64"],"@stdlib/utils/compose":["@stdlib/utils/async/compose"],"@stdlib/utils/async/compose":["@stdlib/utils/compose"],"@stdlib/os/configdir":["@stdlib/os/homedir","@stdlib/os/tmpdir"],"@stdlib/complex/conj":["@stdlib/complex/imag","@stdlib/complex/real","@stdlib/complex/reim"],"@stdlib/utils/constant-function":["@stdlib/utils/argument-function","@stdlib/utils/identity-function"],"@stdlib/streams/node/from-constant":["@stdlib/streams/node/from-array","@stdlib/streams/node/from-iterator"],"@stdlib/utils/constructor-name":["@stdlib/utils/function-name"],"@stdlib/assert/contains":[],"@stdlib/array/convert":["@stdlib/array/convert-same"],"@stdlib/array/convert-same":["@stdlib/array/convert"],"@stdlib/utils/convert-path":[],"@stdlib/utils/copy":["@stdlib/utils/merge"],"@stdlib/buffer/from-buffer":["@stdlib/buffer/alloc-unsafe","@stdlib/buffer/ctor"],"@stdlib/utils/count-by":["@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/utils/async/count-by":["@stdlib/utils/count-by","@stdlib/utils/async/group-by","@stdlib/utils/async/tabulate-by"],"@stdlib/utils/curry":["@stdlib/utils/curry-right","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/utils/curry-right":["@stdlib/utils/curry","@stdlib/utils/uncurry","@stdlib/utils/uncurry-right"],"@stdlib/process/cwd":["@stdlib/process/chdir"],"@stdlib/datasets/dale-chall-new":[],"@stdlib/datasets":[],"@stdlib/time/day-of-quarter":["@stdlib/time/day-of-year"],"@stdlib/time/day-of-year":["@stdlib/time/day-of-quarter"],"@stdlib/time/days-in-month":["@stdlib/time/days-in-year"],"@stdlib/time/days-in-year":["@stdlib/time/days-in-month"],"@stdlib/streams/node/debug-sink":["@stdlib/streams/node/debug","@stdlib/streams/node/inspect-sink"],"@stdlib/streams/node/debug":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/assert/deep-equal":["@stdlib/assert/is-strict-equal","@stdlib/assert/is-same-value"],"@stdlib/utils/deep-get":["@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-own-property":["@stdlib/assert/deep-has-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/assert/deep-has-property":["@stdlib/assert/deep-has-own-property","@stdlib/assert/has-own-property","@stdlib/utils/deep-get","@stdlib/utils/deep-pluck","@stdlib/utils/deep-set"],"@stdlib/utils/deep-pluck":["@stdlib/utils/deep-get","@stdlib/utils/deep-set"],"@stdlib/utils/deep-set":["@stdlib/utils/deep-get","@stdlib/utils/deep-pluck"],"@stdlib/utils/define-memoized-property":["@stdlib/utils/define-memoized-read-only-property","@stdlib/utils/define-property"],"@stdlib/utils/define-properties":["@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-property":["@stdlib/utils/define-properties","@stdlib/utils/define-read-only-property"],"@stdlib/utils/dirname":["@stdlib/utils/extname"],"@stdlib/utils/doubly-linked-list":["@stdlib/utils/linked-list","@stdlib/utils/stack"],"@stdlib/utils/do-until":["@stdlib/utils/async/do-until","@stdlib/utils/do-until-each","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-until":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-until-each":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/until-each"],"@stdlib/utils/do-until-each-right":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/until-each-right"],"@stdlib/utils/do-while":["@stdlib/utils/do-until","@stdlib/utils/async/do-while","@stdlib/utils/do-while-each","@stdlib/utils/until","@stdlib/utils/while"],"@stdlib/utils/async/do-while":["@stdlib/utils/async/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/async/while"],"@stdlib/utils/do-while-each":["@stdlib/utils/do-until-each","@stdlib/utils/do-while-each-right","@stdlib/utils/while-each"],"@stdlib/utils/do-while-each-right":["@stdlib/utils/do-until-each-right","@stdlib/utils/do-while-each","@stdlib/utils/while-each-right"],"@stdlib/constants/math/float64-e":[],"@stdlib/streams/node/empty":["@stdlib/streams/node/from-constant"],"@stdlib/string/ends-with":["@stdlib/string/starts-with"],"@stdlib/utils/enumerable-properties":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties"],"@stdlib/utils/enumerable-properties-in":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties-in"],"@stdlib/utils/enumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols"],"@stdlib/utils/enumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/keys-in","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols-in"],"@stdlib/process/env":["@stdlib/process/argv"],"@stdlib/constants/math/float64-eps":["@stdlib/constants/math/float32-eps"],"@stdlib/error/to-json":["@stdlib/error/reviver"],"@stdlib/constants/math/float64-eulergamma":[],"@stdlib/utils/every":["@stdlib/utils/any","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some"],"@stdlib/utils/every-by":["@stdlib/utils/any-by","@stdlib/utils/every-by-right","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some-by"],"@stdlib/utils/async/every-by":["@stdlib/utils/async/any-by","@stdlib/utils/every-by","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/async/some-by"],"@stdlib/utils/every-by-right":["@stdlib/utils/any-by","@stdlib/utils/every","@stdlib/utils/every-by","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by-right"],"@stdlib/utils/async/every-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by","@stdlib/utils/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/eval":[],"@stdlib/fs/exists":["@stdlib/fs/read-file","@stdlib/fs/read-dir"],"@stdlib/nlp/expand-contractions":[],"@stdlib/utils/extname":["@stdlib/utils/dirname"],"@stdlib/fastmath/special/abs":["@stdlib/math/base/special/abs"],"@stdlib/fastmath/special/acosh":["@stdlib/math/base/special/acosh"],"@stdlib/fastmath/special/alpha-max-plus-beta-min":["@stdlib/math/base/special/hypot"],"@stdlib/fastmath/special/asinh":["@stdlib/math/base/special/asinh"],"@stdlib/fastmath/special/atanh":["@stdlib/math/base/special/atanh"],"@stdlib/fastmath/special/hypot":["@stdlib/math/base/special/hypot"],"@stdlib/fastmath/special/uint32-log2":["@stdlib/math/base/special/log2"],"@stdlib/fastmath/special/max":["@stdlib/math/base/special/max"],"@stdlib/fastmath/special/min":["@stdlib/math/base/special/min"],"@stdlib/fastmath/special/pow-int":["@stdlib/math/base/special/pow"],"@stdlib/fastmath/special/uint32-sqrt":["@stdlib/math/base/special/sqrt"],"@stdlib/datasets/female-first-names-en":["@stdlib/datasets/male-first-names-en"],"@stdlib/utils/fifo":["@stdlib/utils/stack"],"@stdlib/utils/find":[],"@stdlib/utils/flatten-array":["@stdlib/utils/flatten-object"],"@stdlib/utils/flatten-object":["@stdlib/utils/flatten-array"],"@stdlib/stats/fligner-test":["@stdlib/stats/bartlett-test"],"@stdlib/constants/math/float16-cbrt-eps":["@stdlib/constants/math/float16-eps","@stdlib/constants/math/float16-sqrt-eps","@stdlib/constants/math/float32-cbrt-eps","@stdlib/constants/math/float64-cbrt-eps"],"@stdlib/constants/math/float16-eps":["@stdlib/constants/math/float32-eps","@stdlib/constants/math/float64-eps"],"@stdlib/constants/math/float16-exponent-bias":["@stdlib/constants/math/float32-exponent-bias","@stdlib/constants/math/float64-exponent-bias"],"@stdlib/constants/math/float16-max":["@stdlib/constants/math/float32-max","@stdlib/constants/math/float64-max"],"@stdlib/constants/math/float16-max-safe-integer":["@stdlib/constants/math/float16-min-safe-integer","@stdlib/constants/math/float32-max-safe-integer","@stdlib/constants/math/float64-max-safe-integer"],"@stdlib/constants/math/float16-min-safe-integer":["@stdlib/constants/math/float16-max-safe-integer","@stdlib/constants/math/float32-min-safe-integer","@stdlib/constants/math/float64-min-safe-integer"],"@stdlib/constants/math/float16-ninf":["@stdlib/constants/math/float16-pinf","@stdlib/constants/math/float32-ninf","@stdlib/constants/math/float64-ninf"],"@stdlib/constants/math/float16-num-bytes":["@stdlib/constants/math/float32-num-bytes","@stdlib/constants/math/float64-num-bytes"],"@stdlib/constants/math/float16-pinf":["@stdlib/constants/math/float16-ninf","@stdlib/constants/math/float32-pinf","@stdlib/constants/math/float64-pinf"],"@stdlib/constants/math/float16-precision":["@stdlib/constants/math/float32-precision","@stdlib/constants/math/float64-precision"],"@stdlib/constants/math/float16-smallest-normal":["@stdlib/constants/math/float16-smallest-subnormal","@stdlib/constants/math/float32-smallest-normal","@stdlib/constants/math/float64-smallest-normal"],"@stdlib/constants/math/float16-smallest-subnormal":["@stdlib/constants/math/float16-smallest-normal","@stdlib/constants/math/float32-smallest-subnormal","@stdlib/constants/math/float64-smallest-subnormal"],"@stdlib/constants/math/float16-sqrt-eps":["@stdlib/constants/math/float16-eps","@stdlib/constants/math/float32-sqrt-eps","@stdlib/constants/math/float64-sqrt-eps"],"@stdlib/constants/math/float32-cbrt-eps":["@stdlib/constants/math/float32-eps","@stdlib/constants/math/float32-sqrt-eps","@stdlib/constants/math/float64-cbrt-eps"],"@stdlib/constants/math/float32-eps":["@stdlib/constants/math/float64-eps"],"@stdlib/constants/math/float32-exponent-bias":["@stdlib/constants/math/float16-exponent-bias","@stdlib/constants/math/float64-exponent-bias"],"@stdlib/constants/math/float32-max":["@stdlib/constants/math/float16-max","@stdlib/constants/math/float64-max"],"@stdlib/constants/math/float32-max-safe-integer":["@stdlib/constants/math/float16-max-safe-integer","@stdlib/constants/math/float32-min-safe-integer","@stdlib/constants/math/float64-max-safe-integer"],"@stdlib/constants/math/float32-min-safe-integer":["@stdlib/constants/math/float16-min-safe-integer","@stdlib/constants/math/float32-max-safe-integer","@stdlib/constants/math/float64-min-safe-integer"],"@stdlib/constants/math/float32-ninf":["@stdlib/constants/math/float32-pinf","@stdlib/constants/math/float64-ninf"],"@stdlib/constants/math/float32-num-bytes":["@stdlib/constants/math/float16-num-bytes","@stdlib/constants/math/float64-num-bytes"],"@stdlib/constants/math/float32-pinf":["@stdlib/constants/math/float32-ninf","@stdlib/constants/math/float64-pinf"],"@stdlib/constants/math/float32-precision":["@stdlib/constants/math/float16-precision","@stdlib/constants/math/float64-precision"],"@stdlib/constants/math/float32-smallest-normal":["@stdlib/constants/math/float32-smallest-subnormal","@stdlib/constants/math/float64-smallest-normal"],"@stdlib/constants/math/float32-smallest-subnormal":["@stdlib/constants/math/float32-smallest-normal","@stdlib/constants/math/float64-smallest-subnormal"],"@stdlib/constants/math/float32-sqrt-eps":["@stdlib/constants/math/float32-eps","@stdlib/constants/math/float64-sqrt-eps"],"@stdlib/array/float32":["@stdlib/array/buffer","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/math/float64-exponent-bias":["@stdlib/constants/math/float16-exponent-bias","@stdlib/constants/math/float32-exponent-bias"],"@stdlib/constants/math/float64-high-word-exponent-mask":["@stdlib/constants/math/float64-high-word-significand-mask"],"@stdlib/constants/math/float64-high-word-significand-mask":["@stdlib/constants/math/float64-high-word-exponent-mask"],"@stdlib/constants/math/float64-max":["@stdlib/constants/math/float16-max","@stdlib/constants/math/float32-max"],"@stdlib/constants/math/float64-max-base2-exponent":["@stdlib/constants/math/float64-max-base10-exponent","@stdlib/constants/math/float64-max-base2-exponent-subnormal","@stdlib/constants/math/float64-min-base2-exponent"],"@stdlib/constants/math/float64-max-base2-exponent-subnormal":["@stdlib/constants/math/float64-max-base10-exponent-subnormal","@stdlib/constants/math/float64-max-base2-exponent","@stdlib/constants/math/float64-min-base2-exponent-subnormal"],"@stdlib/constants/math/float64-max-base10-exponent":["@stdlib/constants/math/float64-max-base10-exponent-subnormal","@stdlib/constants/math/float64-max-base2-exponent","@stdlib/constants/math/float64-min-base10-exponent"],"@stdlib/constants/math/float64-max-base10-exponent-subnormal":["@stdlib/constants/math/float64-max-base10-exponent","@stdlib/constants/math/float64-max-base2-exponent-subnormal","@stdlib/constants/math/float64-min-base10-exponent-subnormal"],"@stdlib/constants/math/float64-max-ln":["@stdlib/constants/math/float64-min-ln"],"@stdlib/constants/math/float64-max-safe-fibonacci":["@stdlib/constants/math/float64-max-safe-nth-fibonacci"],"@stdlib/constants/math/float64-max-safe-integer":["@stdlib/constants/math/float16-max-safe-integer","@stdlib/constants/math/float32-max-safe-integer","@stdlib/constants/math/float64-min-safe-integer"],"@stdlib/constants/math/float64-max-safe-lucas":["@stdlib/constants/math/float64-max-safe-fibonacci","@stdlib/constants/math/float64-max-safe-nth-lucas"],"@stdlib/constants/math/float64-max-safe-nth-fibonacci":["@stdlib/constants/math/float64-max-safe-fibonacci"],"@stdlib/constants/math/float64-max-safe-nth-lucas":["@stdlib/constants/math/float64-max-safe-lucas","@stdlib/constants/math/float64-max-safe-nth-fibonacci"],"@stdlib/constants/math/float64-min-base2-exponent":["@stdlib/constants/math/float64-max-base2-exponent","@stdlib/constants/math/float64-min-base10-exponent","@stdlib/constants/math/float64-min-base2-exponent-subnormal"],"@stdlib/constants/math/float64-min-base2-exponent-subnormal":["@stdlib/constants/math/float64-max-base2-exponent-subnormal","@stdlib/constants/math/float64-min-base10-exponent-subnormal","@stdlib/constants/math/float64-min-base2-exponent"],"@stdlib/constants/math/float64-min-base10-exponent":["@stdlib/constants/math/float64-max-base10-exponent","@stdlib/constants/math/float64-min-base10-exponent-subnormal","@stdlib/constants/math/float64-min-base2-exponent"],"@stdlib/constants/math/float64-min-base10-exponent-subnormal":["@stdlib/constants/math/float64-max-base10-exponent-subnormal","@stdlib/constants/math/float64-min-base10-exponent","@stdlib/constants/math/float64-min-base2-exponent-subnormal"],"@stdlib/constants/math/float64-min-ln":["@stdlib/constants/math/float64-max-ln"],"@stdlib/constants/math/float64-min-safe-integer":["@stdlib/constants/math/float16-min-safe-integer","@stdlib/constants/math/float32-min-safe-integer","@stdlib/constants/math/float64-max-safe-integer"],"@stdlib/constants/math/float64-num-bytes":["@stdlib/constants/math/float16-num-bytes","@stdlib/constants/math/float32-num-bytes"],"@stdlib/constants/math/float64-precision":["@stdlib/constants/math/float16-precision","@stdlib/constants/math/float32-precision"],"@stdlib/constants/math/float64-smallest-normal":["@stdlib/constants/math/float32-smallest-normal","@stdlib/constants/math/float64-smallest-subnormal"],"@stdlib/constants/math/float64-smallest-subnormal":["@stdlib/constants/math/float32-smallest-subnormal","@stdlib/constants/math/float64-smallest-normal"],"@stdlib/array/float64":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/utils/for-each":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/async/for-each":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/utils/for-each-right":["@stdlib/utils/for-each","@stdlib/utils/async/for-each-right"],"@stdlib/utils/async/for-each-right":["@stdlib/utils/async/for-each","@stdlib/utils/for-each-right"],"@stdlib/utils/for-in":["@stdlib/utils/for-each","@stdlib/utils/for-own"],"@stdlib/utils/for-own":["@stdlib/utils/for-each","@stdlib/utils/for-in"],"@stdlib/constants/math/float64-fourth-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/constants/math/float64-fourth-root-eps":["@stdlib/constants/math/float64-eps"],"@stdlib/datasets/frb-sf-wage-rigidity":[],"@stdlib/string/from-code-point":[],"@stdlib/utils/function-name":["@stdlib/utils/constructor-name"],"@stdlib/utils/function-sequence":["@stdlib/utils/compose","@stdlib/utils/async/function-sequence"],"@stdlib/utils/async/function-sequence":["@stdlib/utils/async/compose","@stdlib/utils/function-sequence"],"@stdlib/constants/math/float64-gamma-lanczos-g":[],"@stdlib/process/getegid":["@stdlib/process/geteuid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/geteuid":["@stdlib/process/getegid","@stdlib/process/getgid","@stdlib/process/getuid"],"@stdlib/process/getgid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getuid"],"@stdlib/utils/global":[],"@stdlib/utils/get-prototype-of":["@stdlib/assert/is-prototype-of"],"@stdlib/process/getuid":["@stdlib/process/getegid","@stdlib/process/geteuid","@stdlib/process/getgid"],"@stdlib/constants/math/float64-glaisher-kinkelin":[],"@stdlib/utils/group":["@stdlib/utils/bifurcate","@stdlib/utils/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-by":["@stdlib/utils/bifurcate-by","@stdlib/utils/count-by","@stdlib/utils/group"],"@stdlib/utils/async/group-by":["@stdlib/utils/async/bifurcate-by","@stdlib/utils/async/count-by","@stdlib/utils/group-by"],"@stdlib/utils/group-in":["@stdlib/utils/bifurcate-in","@stdlib/utils/group-by","@stdlib/utils/group-own"],"@stdlib/utils/group-own":["@stdlib/utils/bifurcate-own","@stdlib/utils/group","@stdlib/utils/group-by"],"@stdlib/constants/math/float64-half-ln-two":["@stdlib/constants/math/float64-ln-two"],"@stdlib/constants/math/float64-half-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/datasets/harrison-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices-corrected","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/datasets/harrison-boston-house-prices-corrected":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/pace-boston-house-prices"],"@stdlib/assert/has-arraybuffer-support":["@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-sharedarraybuffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-async-await-support":[],"@stdlib/assert/has-async-iterator-symbol-support":["@stdlib/assert/has-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-class-support":[],"@stdlib/assert/has-define-properties-support":["@stdlib/assert/has-define-property-support"],"@stdlib/assert/has-define-property-support":["@stdlib/assert/has-define-properties-support"],"@stdlib/assert/has-float32array-support":[],"@stdlib/assert/has-float64array-support":[],"@stdlib/assert/has-function-name-support":[],"@stdlib/assert/has-generator-support":[],"@stdlib/assert/has-int8array-support":[],"@stdlib/assert/has-int16array-support":[],"@stdlib/assert/has-int32array-support":[],"@stdlib/assert/has-iterator-symbol-support":["@stdlib/assert/has-async-iterator-symbol-support","@stdlib/assert/has-symbol-support"],"@stdlib/assert/has-map-support":[],"@stdlib/assert/has-node-buffer-support":[],"@stdlib/assert/has-own-property":["@stdlib/assert/has-property"],"@stdlib/assert/has-property":["@stdlib/assert/has-own-property"],"@stdlib/assert/has-proxy-support":[],"@stdlib/assert/has-set-support":[],"@stdlib/assert/has-sharedarraybuffer-support":["@stdlib/assert/has-arraybuffer-support","@stdlib/assert/has-float32array-support","@stdlib/assert/has-float64array-support","@stdlib/assert/has-int16array-support","@stdlib/assert/has-int32array-support","@stdlib/assert/has-int8array-support","@stdlib/assert/has-node-buffer-support","@stdlib/assert/has-uint16array-support","@stdlib/assert/has-uint32array-support","@stdlib/assert/has-uint8array-support","@stdlib/assert/has-uint8clampedarray-support"],"@stdlib/assert/has-symbol-support":["@stdlib/assert/has-iterator-symbol-support"],"@stdlib/assert/has-tostringtag-support":[],"@stdlib/assert/has-uint8array-support":[],"@stdlib/assert/has-uint8clampedarray-support":[],"@stdlib/assert/has-uint16array-support":[],"@stdlib/assert/has-uint32array-support":[],"@stdlib/assert/has-weakmap-support":[],"@stdlib/assert/has-weakset-support":[],"@stdlib/assert/has-wasm-support":[],"@stdlib/datasets/herndon-venus-semidiameters":[],"@stdlib/os/homedir":["@stdlib/os/configdir","@stdlib/os/tmpdir"],"@stdlib/constants/time/hours-in-day":["@stdlib/constants/time/hours-in-week"],"@stdlib/constants/time/hours-in-week":["@stdlib/constants/time/hours-in-day"],"@stdlib/time/hours-in-month":["@stdlib/time/hours-in-year"],"@stdlib/time/hours-in-year":["@stdlib/time/hours-in-month"],"@stdlib/net/http-server":[],"@stdlib/utils/identity-function":["@stdlib/utils/constant-function"],"@stdlib/utils/if-else":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/utils/async/if-else":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/if-then":["@stdlib/utils/async/if-then","@stdlib/utils/if-else"],"@stdlib/utils/async/if-then":["@stdlib/utils/async/if-else","@stdlib/utils/if-then"],"@stdlib/complex/imag":["@stdlib/complex/real","@stdlib/complex/reim"],"@stdlib/datasets/img-acanthus-mollis":["@stdlib/datasets/img-allium-oreophilum"],"@stdlib/datasets/img-airplane-from-above":[],"@stdlib/datasets/img-allium-oreophilum":["@stdlib/datasets/img-acanthus-mollis"],"@stdlib/datasets/img-black-canyon":[],"@stdlib/datasets/img-dust-bowl-home":[],"@stdlib/datasets/img-french-alpine-landscape":[],"@stdlib/datasets/img-locomotion-house-cat":["@stdlib/datasets/img-locomotion-nude-male"],"@stdlib/datasets/img-locomotion-nude-male":["@stdlib/datasets/img-locomotion-house-cat"],"@stdlib/datasets/img-march-pastoral":[],"@stdlib/datasets/img-nagasaki-boats":[],"@stdlib/stats/incr/apcorr":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/stats/incr/count":["@stdlib/stats/incr/mean","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/covariance":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/covmat":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/cv":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mcv","@stdlib/stats/incr/stdev","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/ewmean":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean","@stdlib/stats/incr/wmean"],"@stdlib/stats/incr/ewstdev":["@stdlib/stats/incr/ewvariance","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/ewvariance":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/ewstdev","@stdlib/stats/incr/variance","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/gmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/grubbs":["@stdlib/stats/incr/mgrubbs"],"@stdlib/stats/incr/hmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/summary"],"@stdlib/ml/incr/kmeans":[],"@stdlib/stats/incr/kurtosis":["@stdlib/stats/incr/mean","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/maape":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mape","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmaape"],"@stdlib/stats/incr/mae":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmae"],"@stdlib/stats/incr/mapcorr":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mpcorr2"],"@stdlib/stats/incr/mape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/max":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/maxabs":["@stdlib/stats/incr/max","@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs"],"@stdlib/stats/incr/mcovariance":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mcv":["@stdlib/stats/incr/cv","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/mvmr"],"@stdlib/stats/incr/mda":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmda"],"@stdlib/stats/incr/me":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mean","@stdlib/stats/incr/mme"],"@stdlib/stats/incr/mean":["@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/meanabs":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/meanabs2":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/meanstdev":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/meanvar":["@stdlib/stats/incr/mean","@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mgmean":["@stdlib/stats/incr/gmean","@stdlib/stats/incr/mhmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mgrubbs":["@stdlib/stats/incr/grubbs"],"@stdlib/stats/incr/mhmean":["@stdlib/stats/incr/hmean","@stdlib/stats/incr/mgmean","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/midrange":["@stdlib/stats/incr/mean","@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/min":["@stdlib/stats/incr/max","@stdlib/stats/incr/midrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/range","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/minabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/min","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/minmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mminmax","@stdlib/stats/incr/range"],"@stdlib/stats/incr/minmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/minabs","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mminmaxabs"],"@stdlib/stats/incr/mmaape":["@stdlib/stats/incr/maape","@stdlib/stats/incr/mmape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmae":["@stdlib/stats/incr/mae","@stdlib/stats/incr/mme","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmape":["@stdlib/stats/incr/mape","@stdlib/stats/incr/mmaape","@stdlib/stats/incr/mmpe","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mmaxabs":["@stdlib/stats/incr/maxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mminabs"],"@stdlib/stats/incr/mmda":["@stdlib/stats/incr/mda","@stdlib/stats/incr/mmape"],"@stdlib/stats/incr/mme":["@stdlib/stats/incr/me","@stdlib/stats/incr/mmae","@stdlib/stats/incr/mmean"],"@stdlib/stats/incr/mmean":["@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmeanabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/mmean","@stdlib/stats/incr/msumabs"],"@stdlib/stats/incr/mmeanabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msumabs2"],"@stdlib/stats/incr/mmeanstdev":["@stdlib/stats/incr/meanstdev","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanvar","@stdlib/stats/incr/mstdev"],"@stdlib/stats/incr/mmeanvar":["@stdlib/stats/incr/meanvar","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmeanstdev","@stdlib/stats/incr/mvariance"],"@stdlib/stats/incr/mmidrange":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mmin":["@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmidrange","@stdlib/stats/incr/mrange","@stdlib/stats/incr/msummary"],"@stdlib/stats/incr/mminabs":["@stdlib/stats/incr/minabs","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin"],"@stdlib/stats/incr/mminmax":["@stdlib/stats/incr/max","@stdlib/stats/incr/min","@stdlib/stats/incr/mmax","@stdlib/stats/incr/minmax","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mrange"],"@stdlib/stats/incr/mminmaxabs":["@stdlib/stats/incr/minmaxabs","@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmaxabs","@stdlib/stats/incr/mmin","@stdlib/stats/incr/mminabs","@stdlib/stats/incr/mminmax"],"@stdlib/stats/incr/mmpe":["@stdlib/stats/incr/mmape","@stdlib/stats/incr/mme","@stdlib/stats/incr/mpe"],"@stdlib/stats/incr/mmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse"],"@stdlib/stats/incr/mpcorr":["@stdlib/stats/incr/mcovariance","@stdlib/stats/incr/mpcorrdist","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/mpcorr2":["@stdlib/stats/incr/mapcorr","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorr2"],"@stdlib/stats/incr/mpcorrdist":["@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/pcorrdist"],"@stdlib/stats/incr/mpe":["@stdlib/stats/incr/mape","@stdlib/stats/incr/me","@stdlib/stats/incr/mmpe"],"@stdlib/stats/incr/mprod":["@stdlib/stats/incr/msum","@stdlib/stats/incr/prod"],"@stdlib/stats/incr/mrange":["@stdlib/stats/incr/mmax","@stdlib/stats/incr/mmean","@stdlib/stats/incr/mmin","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range"],"@stdlib/stats/incr/mrmse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrss","@stdlib/stats/incr/rmse"],"@stdlib/stats/incr/mrss":["@stdlib/stats/incr/rss","@stdlib/stats/incr/mmse","@stdlib/stats/incr/mrmse"],"@stdlib/stats/incr/mse":["@stdlib/stats/incr/mmse","@stdlib/stats/incr/rmse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/mstdev":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/stdev"],"@stdlib/stats/incr/msum":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/msummary","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/msumabs":["@stdlib/stats/incr/mmeanabs","@stdlib/stats/incr/msum","@stdlib/stats/incr/sum","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/msumabs2":["@stdlib/stats/incr/mmeanabs2","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sumabs","@stdlib/stats/incr/sumabs2"],"@stdlib/stats/incr/msummary":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msum","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/msumprod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/msum","@stdlib/stats/incr/sumprod"],"@stdlib/stats/incr/mvariance":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/msummary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/mvmr":["@stdlib/stats/incr/mmean","@stdlib/stats/incr/mvariance","@stdlib/stats/incr/vmr"],"@stdlib/stats/incr/pcorr":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/mpcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorr2":["@stdlib/stats/incr/apcorr","@stdlib/stats/incr/mpcorr2","@stdlib/stats/incr/pcorr"],"@stdlib/stats/incr/pcorrdist":["@stdlib/stats/incr/covariance","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/pcorrdistmat":["@stdlib/stats/incr/pcorrdist","@stdlib/stats/incr/pcorrmat"],"@stdlib/stats/incr/pcorrmat":["@stdlib/stats/incr/covmat","@stdlib/stats/incr/pcorr","@stdlib/stats/incr/pcorrdistmat"],"@stdlib/stats/incr/prod":["@stdlib/stats/incr/mprod","@stdlib/stats/incr/sum","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/range":["@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/min","@stdlib/stats/incr/mrange","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/rmse":["@stdlib/stats/incr/mrmse","@stdlib/stats/incr/mse","@stdlib/stats/incr/rss"],"@stdlib/stats/incr/rss":["@stdlib/stats/incr/mrss","@stdlib/stats/incr/mse","@stdlib/stats/incr/rmse"],"@stdlib/stats/incr/skewness":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/math/utils/incrspace":["@stdlib/math/utils/linspace","@stdlib/math/utils/logspace"],"@stdlib/stats/incr/stdev":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/summary","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sum":["@stdlib/stats/incr/count","@stdlib/stats/incr/mean","@stdlib/stats/incr/msum","@stdlib/stats/incr/prod","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/sumabs":["@stdlib/stats/incr/meanabs","@stdlib/stats/incr/msumabs","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/sumabs2":["@stdlib/stats/incr/meanabs2","@stdlib/stats/incr/msumabs2","@stdlib/stats/incr/sumabs"],"@stdlib/stats/incr/summary":["@stdlib/stats/incr/count","@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/max","@stdlib/stats/incr/mean","@stdlib/stats/incr/midrange","@stdlib/stats/incr/min","@stdlib/stats/incr/msummary","@stdlib/stats/incr/range","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/sum","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/sumprod":["@stdlib/stats/incr/msumprod","@stdlib/stats/incr/prod","@stdlib/stats/incr/sum"],"@stdlib/stats/incr/variance":["@stdlib/stats/incr/kurtosis","@stdlib/stats/incr/mean","@stdlib/stats/incr/mstdev","@stdlib/stats/incr/skewness","@stdlib/stats/incr/stdev","@stdlib/stats/incr/summary"],"@stdlib/stats/incr/vmr":["@stdlib/stats/incr/mean","@stdlib/stats/incr/mvmr","@stdlib/stats/incr/variance"],"@stdlib/stats/incr/wmean":["@stdlib/stats/incr/ewmean","@stdlib/stats/incr/mean","@stdlib/stats/incr/mmean"],"@stdlib/ndarray/ind2sub":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/sub2ind"],"@stdlib/utils/index-of":[],"@stdlib/utils/inherit":[],"@stdlib/utils/inherited-enumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-properties"],"@stdlib/utils/inherited-enumerable-property-symbols":["@stdlib/utils/enumerable-properties","@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-keys":["@stdlib/utils/keys","@stdlib/utils/keys-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-nonenumerable-properties":["@stdlib/utils/inherited-enumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/inherited-keys","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-nonenumerable-property-names":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/inherited-nonenumerable-property-symbols":["@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-properties","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/inherited-properties":["@stdlib/utils/properties","@stdlib/utils/properties-in","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptor":["@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptor-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-descriptors":["@stdlib/utils/property-descriptors","@stdlib/utils/property-descriptors-in","@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-names","@stdlib/utils/inherited-property-symbols"],"@stdlib/utils/inherited-property-names":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-symbols","@stdlib/utils/property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/inherited-property-symbols":["@stdlib/utils/inherited-keys","@stdlib/utils/inherited-property-descriptors","@stdlib/utils/inherited-property-names","@stdlib/utils/property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/inherited-writable-properties":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-names":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-names-in","@stdlib/utils/properties"],"@stdlib/utils/inherited-writable-property-symbols":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-property-symbols","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/properties"],"@stdlib/utils/inmap":["@stdlib/utils/for-each","@stdlib/utils/inmap-right"],"@stdlib/utils/async/inmap":["@stdlib/utils/async/for-each","@stdlib/utils/async/inmap-right","@stdlib/utils/inmap"],"@stdlib/utils/inmap-right":["@stdlib/utils/for-each-right","@stdlib/utils/inmap"],"@stdlib/utils/async/inmap-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/inmap","@stdlib/utils/inmap-right"],"@stdlib/streams/node/inspect-sink":["@stdlib/streams/node/debug-sink","@stdlib/streams/node/inspect"],"@stdlib/streams/node/inspect":["@stdlib/streams/node/debug"],"@stdlib/assert/instance-of":["@stdlib/assert/is-prototype-of","@stdlib/utils/constructor-name","@stdlib/utils/inherit","@stdlib/utils/type-of"],"@stdlib/constants/math/int8-max":["@stdlib/constants/math/int8-min"],"@stdlib/constants/math/int8-min":["@stdlib/constants/math/int8-max"],"@stdlib/constants/math/int8-num-bytes":["@stdlib/constants/math/int16-num-bytes","@stdlib/constants/math/int32-num-bytes","@stdlib/constants/math/uint8-num-bytes"],"@stdlib/array/int8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/math/int16-max":["@stdlib/constants/math/int16-min"],"@stdlib/constants/math/int16-min":["@stdlib/constants/math/int16-max"],"@stdlib/constants/math/int16-num-bytes":["@stdlib/constants/math/int32-num-bytes","@stdlib/constants/math/int8-num-bytes","@stdlib/constants/math/uint16-num-bytes"],"@stdlib/array/int16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/math/int32-max":["@stdlib/constants/math/int32-min"],"@stdlib/constants/math/int32-min":["@stdlib/constants/math/int32-max"],"@stdlib/constants/math/int32-num-bytes":["@stdlib/constants/math/int16-num-bytes","@stdlib/constants/math/int8-num-bytes","@stdlib/constants/math/uint32-num-bytes"],"@stdlib/array/int32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/assert/is-big-endian":["@stdlib/assert/is-little-endian"],"@stdlib/assert/is-browser":[],"@stdlib/assert/is-darwin":[],"@stdlib/assert/is-electron":["@stdlib/assert/is-electron-main","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-main":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-renderer"],"@stdlib/assert/is-electron-renderer":["@stdlib/assert/is-electron","@stdlib/assert/is-electron-main"],"@stdlib/assert/is-little-endian":["@stdlib/assert/is-big-endian"],"@stdlib/assert/is-node":[],"@stdlib/assert/is-web-worker":[],"@stdlib/assert/is-windows":[],"@stdlib/assert/is-absolute-path":["@stdlib/assert/is-relative-path"],"@stdlib/assert/is-accessor-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-accessor-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-alphagram":["@stdlib/assert/is-anagram"],"@stdlib/assert/is-alphanumeric":["@stdlib/assert/is-digit-string"],"@stdlib/assert/is-anagram":["@stdlib/assert/is-alphagram"],"@stdlib/assert/is-arguments":[],"@stdlib/assert/is-array":["@stdlib/assert/is-array-like"],"@stdlib/assert/is-array-array":[],"@stdlib/assert/is-arraybuffer":["@stdlib/assert/is-sharedarraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-array-length":["@stdlib/assert/is-array"],"@stdlib/assert/is-array-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like-object"],"@stdlib/assert/is-array-like-object":["@stdlib/assert/is-array","@stdlib/assert/is-array-like"],"@stdlib/assert/is-ascii":["@stdlib/assert/is-string"],"@stdlib/assert/is-between":["@stdlib/assert/is-between-array"],"@stdlib/assert/is-between-array":["@stdlib/assert/is-between"],"@stdlib/assert/is-binary-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-boolean":[],"@stdlib/assert/is-boolean-array":[],"@stdlib/assert/is-boxed-primitive":["@stdlib/assert/is-primitive"],"@stdlib/assert/is-buffer":[],"@stdlib/assert/is-capitalized":["@stdlib/assert/is-string"],"@stdlib/assert/is-centrosymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-circular":["@stdlib/assert/is-circular-array","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-array":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-plain-object"],"@stdlib/assert/is-circular-plain-object":["@stdlib/assert/is-circular","@stdlib/assert/is-circular-array"],"@stdlib/assert/is-collection":["@stdlib/assert/is-array-like"],"@stdlib/assert/is-complex":["@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex64array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex128":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64"],"@stdlib/assert/is-complex128array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex128","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex-typed-array"],"@stdlib/assert/is-complex-like":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64","@stdlib/assert/is-complex128"],"@stdlib/assert/is-complex-typed-array":["@stdlib/assert/is-complex","@stdlib/assert/is-complex64array","@stdlib/assert/is-complex128array"],"@stdlib/assert/is-configurable-property":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-configurable-property-in":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-data-property":["@stdlib/assert/has-own-property","@stdlib/assert/is-accessor-property","@stdlib/assert/is-data-property-in"],"@stdlib/assert/is-data-property-in":["@stdlib/assert/has-property","@stdlib/assert/is-accessor-property-in","@stdlib/assert/is-data-property"],"@stdlib/assert/is-date-object":[],"@stdlib/assert/is-digit-string":["@stdlib/assert/is-hex-string","@stdlib/assert/is-string"],"@stdlib/assert/is-email-address":[],"@stdlib/assert/is-empty-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-empty-object":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-empty-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-enumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-enumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-error":[],"@stdlib/assert/is-eval-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-even":["@stdlib/assert/is-odd"],"@stdlib/assert/is-falsy":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-falsy-array":["@stdlib/assert/is-falsy","@stdlib/assert/is-truthy-array"],"@stdlib/assert/is-finite":["@stdlib/assert/is-finite-array","@stdlib/assert/is-infinite"],"@stdlib/assert/is-finite-array":["@stdlib/assert/is-finite","@stdlib/assert/is-infinite"],"@stdlib/assert/is-float32array":["@stdlib/assert/is-float64array"],"@stdlib/assert/is-float64array":["@stdlib/assert/is-float32array"],"@stdlib/assert/is-function":[],"@stdlib/assert/is-function-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-generator-object":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object-like"],"@stdlib/assert/is-generator-object-like":["@stdlib/assert/has-generator-support","@stdlib/assert/is-generator-object"],"@stdlib/assert/is-hex-string":["@stdlib/assert/is-string"],"@stdlib/assert/is-infinite":["@stdlib/assert/is-finite"],"@stdlib/assert/is-inherited-property":["@stdlib/assert/has-own-property","@stdlib/assert/has-property"],"@stdlib/assert/is-int8array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int32array"],"@stdlib/assert/is-int16array":["@stdlib/assert/is-int32array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-int32array":["@stdlib/assert/is-int16array","@stdlib/assert/is-int8array"],"@stdlib/assert/is-integer":["@stdlib/assert/is-number"],"@stdlib/assert/is-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-iterable-like":["@stdlib/assert/is-iterator-like"],"@stdlib/assert/is-iterator-like":["@stdlib/assert/is-iterable-like"],"@stdlib/assert/is-json":[],"@stdlib/assert/is-leap-year":[],"@stdlib/assert/is-lowercase":["@stdlib/assert/is-string","@stdlib/assert/is-uppercase"],"@stdlib/assert/is-matrix-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-method":["@stdlib/assert/has-own-property","@stdlib/assert/is-function","@stdlib/assert/is-method-in"],"@stdlib/assert/is-method-in":["@stdlib/assert/has-property","@stdlib/assert/is-function","@stdlib/assert/is-method"],"@stdlib/assert/is-named-typed-tuple-like":["@stdlib/utils/named-typed-tuple"],"@stdlib/assert/is-nan":["@stdlib/assert/is-number"],"@stdlib/assert/is-nan-array":["@stdlib/assert/is-nan"],"@stdlib/assert/is-native-function":["@stdlib/assert/is-function"],"@stdlib/assert/is-ndarray-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-typed-array-like","@stdlib/assert/is-vector-like"],"@stdlib/assert/is-negative-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-negative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-negative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-negative-zero":["@stdlib/assert/is-number","@stdlib/assert/is-positive-zero"],"@stdlib/assert/is-node-builtin":[],"@stdlib/assert/is-node-duplex-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-readable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-repl":[],"@stdlib/assert/is-node-stream-like":[],"@stdlib/assert/is-node-transform-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-node-writable-stream-like":["@stdlib/assert/is-node-stream-like"],"@stdlib/assert/is-nonconfigurable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonconfigurable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonenumerable-property":["@stdlib/assert/is-configurable-property","@stdlib/assert/is-enumerable-property","@stdlib/assert/is-nonconfigurable-property","@stdlib/assert/is-nonenumerable-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-nonenumerable-property-in":["@stdlib/assert/is-configurable-property-in","@stdlib/assert/is-enumerable-property-in","@stdlib/assert/is-nonconfigurable-property-in","@stdlib/assert/is-nonenumerable-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-nonnegative-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-nonnegative-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonnegative-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-nonnegative-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-nonpositive-integer-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonpositive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-nonpositive-number-array":["@stdlib/assert/is-array"],"@stdlib/assert/is-nonsymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-null":["@stdlib/assert/is-undefined","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-null-array":["@stdlib/assert/is-array","@stdlib/assert/is-null"],"@stdlib/assert/is-number":[],"@stdlib/assert/is-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-numeric-array"],"@stdlib/assert/is-numeric-array":["@stdlib/assert/is-array","@stdlib/assert/is-number-array","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-object":["@stdlib/assert/is-object-like","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-object"],"@stdlib/assert/is-object-like":["@stdlib/assert/is-object","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-odd":["@stdlib/assert/is-even"],"@stdlib/time/iso-weeks-in-year":[],"@stdlib/assert/is-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-square-matrix","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-plain-object":["@stdlib/assert/is-object"],"@stdlib/assert/is-plain-object-array":["@stdlib/assert/is-array","@stdlib/assert/is-plain-object"],"@stdlib/assert/is-positive-integer":["@stdlib/assert/is-integer"],"@stdlib/assert/is-positive-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-integer","@stdlib/assert/is-positive-integer"],"@stdlib/assert/is-positive-number":["@stdlib/assert/is-number"],"@stdlib/assert/is-positive-number-array":["@stdlib/assert/is-array","@stdlib/assert/is-number","@stdlib/assert/is-positive-number"],"@stdlib/assert/is-positive-zero":["@stdlib/assert/is-number","@stdlib/assert/is-negative-zero"],"@stdlib/assert/is-primitive":["@stdlib/assert/is-boxed-primitive"],"@stdlib/assert/is-primitive-array":["@stdlib/assert/is-array","@stdlib/assert/is-primitive"],"@stdlib/assert/is-prng-like":[],"@stdlib/assert/is-probability":["@stdlib/assert/is-number"],"@stdlib/assert/is-probability-array":["@stdlib/assert/is-array","@stdlib/assert/is-probability"],"@stdlib/assert/is-prototype-of":["@stdlib/utils/get-prototype-of"],"@stdlib/assert/is-range-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-readable-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-readable-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-only-property":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-only-property-in":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-read-write-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-readable-property","@stdlib/assert/is-writable-property"],"@stdlib/assert/is-read-write-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property","@stdlib/assert/is-readable-property-in","@stdlib/assert/is-writable-property-in"],"@stdlib/assert/is-reference-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-regexp":[],"@stdlib/assert/is-regexp-string":["@stdlib/assert/is-regexp"],"@stdlib/assert/is-relative-path":["@stdlib/assert/is-absolute-path"],"@stdlib/assert/is-safe-integer":["@stdlib/assert/is-integer","@stdlib/assert/is-number"],"@stdlib/assert/is-safe-integer-array":["@stdlib/assert/is-array","@stdlib/assert/is-safe-integer"],"@stdlib/assert/is-same-value":["@stdlib/assert/is-same-value-zero","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-same-value-zero":["@stdlib/assert/is-same-value","@stdlib/assert/is-strict-equal"],"@stdlib/assert/is-sharedarraybuffer":["@stdlib/assert/is-arraybuffer","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-skew-centrosymmetric-matrix":["@stdlib/assert/is-centrosymmetric-matrix","@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-persymmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-persymmetric-matrix","@stdlib/assert/is-skew-symmetric-matrix"],"@stdlib/assert/is-skew-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-skew-symmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-square-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-symmetric-matrix"],"@stdlib/assert/is-strict-equal":["@stdlib/assert/is-same-value"],"@stdlib/assert/is-string":[],"@stdlib/assert/is-string-array":["@stdlib/assert/is-array","@stdlib/assert/is-string"],"@stdlib/assert/is-symbol":[],"@stdlib/assert/is-symbol-array":["@stdlib/assert/is-array","@stdlib/assert/is-symbol"],"@stdlib/assert/is-symmetric-matrix":["@stdlib/assert/is-matrix-like","@stdlib/assert/is-nonsymmetric-matrix","@stdlib/assert/is-square-matrix"],"@stdlib/assert/is-syntax-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-truthy":["@stdlib/assert/is-falsy"],"@stdlib/assert/is-truthy-array":["@stdlib/assert/is-falsy-array","@stdlib/assert/is-truthy"],"@stdlib/assert/is-typed-array":["@stdlib/assert/is-array","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-typed-array-length":["@stdlib/assert/is-array-length","@stdlib/assert/is-typed-array"],"@stdlib/assert/is-typed-array-like":["@stdlib/assert/is-typed-array"],"@stdlib/assert/is-type-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-uint8array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint32array"],"@stdlib/assert/is-uint8clampedarray":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint16array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint32array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-uint32array":["@stdlib/assert/is-typed-array","@stdlib/assert/is-uint16array","@stdlib/assert/is-uint8array"],"@stdlib/assert/is-unc-path":[],"@stdlib/assert/is-undefined":["@stdlib/assert/is-null","@stdlib/assert/is-undefined-or-null"],"@stdlib/assert/is-undefined-or-null":["@stdlib/assert/is-null","@stdlib/assert/is-undefined"],"@stdlib/assert/is-unity-probability-array":["@stdlib/assert/is-probability","@stdlib/assert/is-probability-array"],"@stdlib/assert/is-uppercase":["@stdlib/assert/is-lowercase","@stdlib/assert/is-string"],"@stdlib/assert/is-uri":[],"@stdlib/assert/is-uri-error":["@stdlib/assert/is-error"],"@stdlib/assert/is-vector-like":["@stdlib/assert/is-array","@stdlib/assert/is-array-like","@stdlib/assert/is-matrix-like","@stdlib/assert/is-ndarray-like","@stdlib/assert/is-typed-array-like"],"@stdlib/assert/is-whitespace":["@stdlib/regexp/whitespace"],"@stdlib/assert/is-writable-property":["@stdlib/assert/is-readable-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/assert/is-writable-property-in":["@stdlib/assert/is-readable-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property":["@stdlib/assert/is-read-only-property","@stdlib/assert/is-read-write-property","@stdlib/assert/is-writable-property","@stdlib/assert/is-write-only-property-in"],"@stdlib/assert/is-write-only-property-in":["@stdlib/assert/is-read-only-property-in","@stdlib/assert/is-read-write-property-in","@stdlib/assert/is-writable-property-in","@stdlib/assert/is-write-only-property"],"@stdlib/math/iter/add":["@stdlib/math/iter/divide","@stdlib/math/iter/multiply","@stdlib/math/iter/subtract"],"@stdlib/iter/advance":["@stdlib/iter/head","@stdlib/iter/slice"],"@stdlib/iter/any":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/any-by":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/array/from-iterator":["@stdlib/array/to-iterator","@stdlib/iter/to-array-view"],"@stdlib/iter/to-array-view":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator","@stdlib/iter/to-array-view-right"],"@stdlib/iter/to-array-view-right":["@stdlib/array/from-iterator","@stdlib/array/to-view-iterator-right","@stdlib/iter/to-array-view"],"@stdlib/streams/node/from-iterator":["@stdlib/streams/node/from-array"],"@stdlib/symbol/iterator":["@stdlib/symbol/ctor"],"@stdlib/simulate/iter/awgn":["@stdlib/simulate/iter/awln","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awln":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awun"],"@stdlib/simulate/iter/awun":["@stdlib/simulate/iter/awgn","@stdlib/simulate/iter/awln"],"@stdlib/simulate/iter/bartlett-hann-pulse":["@stdlib/simulate/iter/bartlett-pulse","@stdlib/simulate/iter/hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/simulate/iter/bartlett-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/concat":[],"@stdlib/iter/constant":["@stdlib/utils/constant-function"],"@stdlib/simulate/iter/cosine-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/counter":["@stdlib/iter/length"],"@stdlib/stats/iter/cugmean":["@stdlib/stats/iter/cuhmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cuhmean":["@stdlib/stats/iter/cugmean","@stdlib/stats/iter/cumean"],"@stdlib/stats/iter/cumax":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/max"],"@stdlib/stats/iter/cumaxabs":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cuminabs","@stdlib/stats/iter/maxabs"],"@stdlib/stats/iter/cumean":["@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/cusum","@stdlib/stats/iter/mean"],"@stdlib/stats/iter/cumeanabs":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/meanabs"],"@stdlib/stats/iter/cumeanabs2":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusumabs2","@stdlib/stats/iter/meanabs2"],"@stdlib/stats/iter/cumidrange":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumin","@stdlib/stats/iter/curange","@stdlib/stats/iter/midrange"],"@stdlib/stats/iter/cumin":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumidrange","@stdlib/stats/iter/curange","@stdlib/stats/iter/min"],"@stdlib/stats/iter/cuminabs":["@stdlib/stats/iter/cumaxabs","@stdlib/stats/iter/cumin","@stdlib/stats/iter/minabs"],"@stdlib/stats/iter/cuprod":["@stdlib/stats/iter/cusum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/curange":["@stdlib/stats/iter/cumax","@stdlib/stats/iter/cumean","@stdlib/stats/iter/cumin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/cusum":["@stdlib/stats/iter/cumean","@stdlib/stats/iter/sum","@stdlib/stats/iter/cuprod"],"@stdlib/stats/iter/cusumabs":["@stdlib/stats/iter/cumeanabs","@stdlib/stats/iter/cusum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/cusumabs2":["@stdlib/stats/iter/cumeanabs2","@stdlib/stats/iter/cusumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/iter/dedupe":["@stdlib/iter/dedupe-by","@stdlib/iter/unique"],"@stdlib/iter/dedupe-by":["@stdlib/iter/dedupe","@stdlib/iter/unique"],"@stdlib/simulate/iter/dirac-comb":["@stdlib/simulate/iter/pulse"],"@stdlib/math/iter/divide":["@stdlib/math/iter/add","@stdlib/math/iter/divide","@stdlib/math/iter/multiply"],"@stdlib/iter/empty":["@stdlib/iter/constant"],"@stdlib/iter/every":["@stdlib/iter/any","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some"],"@stdlib/iter/every-by":["@stdlib/iter/any-by","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some-by"],"@stdlib/math/iter/fibonacci":["@stdlib/math/base/special/fibonacci","@stdlib/math/iter/nonfibonacci"],"@stdlib/iter/fill":[],"@stdlib/iter/filter":["@stdlib/iter/filter-map","@stdlib/iter/map","@stdlib/iter/reject"],"@stdlib/iter/filter-map":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/first":["@stdlib/iter/head","@stdlib/iter/last","@stdlib/iter/nth"],"@stdlib/simulate/iter/flat-top-pulse":["@stdlib/simulate/iter/pulse"],"@stdlib/iter/flow":["@stdlib/iter/pipeline"],"@stdlib/iter/for-each":["@stdlib/iter/map"],"@stdlib/simulate/iter/hann-pulse":["@stdlib/simulate/iter/bartlett-hann-pulse","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave"],"@stdlib/iter/head":["@stdlib/iter/first","@stdlib/iter/slice"],"@stdlib/iter/intersection":["@stdlib/iter/intersection-by-hash","@stdlib/iter/union","@stdlib/iter/unique"],"@stdlib/iter/intersection-by-hash":["@stdlib/iter/intersection","@stdlib/iter/unique-by-hash"],"@stdlib/simulate/iter/lanczos-pulse":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/periodic-sinc"],"@stdlib/iter/last":["@stdlib/iter/first","@stdlib/iter/nth"],"@stdlib/iter/length":["@stdlib/iter/counter"],"@stdlib/iter/map":["@stdlib/iter/filter","@stdlib/iter/filter-map","@stdlib/iter/for-each","@stdlib/iter/reject"],"@stdlib/iter/mapn":["@stdlib/iter/map"],"@stdlib/stats/iter/max":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/range"],"@stdlib/stats/iter/maxabs":["@stdlib/stats/iter/max","@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs"],"@stdlib/stats/iter/mean":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/stdev","@stdlib/stats/iter/sum","@stdlib/stats/iter/variance"],"@stdlib/stats/iter/meanabs":["@stdlib/stats/iter/mean","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/meanabs2":["@stdlib/stats/iter/mean","@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/sumabs2"],"@stdlib/stats/iter/midrange":["@stdlib/stats/iter/mean","@stdlib/stats/iter/max","@stdlib/stats/iter/min","@stdlib/stats/iter/range"],"@stdlib/stats/iter/min":["@stdlib/stats/iter/max","@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/minabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/min","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmax":["@stdlib/stats/iter/max","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmaxabs":["@stdlib/stats/iter/maxabs","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mminabs"],"@stdlib/stats/iter/mmean":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum"],"@stdlib/stats/iter/mmeanabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/mmean","@stdlib/stats/iter/msumabs"],"@stdlib/stats/iter/mmeanabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msumabs2"],"@stdlib/stats/iter/mmidrange":["@stdlib/stats/iter/midrange","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmin","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mmin":["@stdlib/stats/iter/min","@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmidrange","@stdlib/stats/iter/mrange"],"@stdlib/stats/iter/mminabs":["@stdlib/stats/iter/minabs","@stdlib/stats/iter/mmaxabs","@stdlib/stats/iter/mmin"],"@stdlib/math/iter/mod":["@stdlib/math/iter/divide"],"@stdlib/stats/iter/mprod":["@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/mrange":["@stdlib/stats/iter/mmax","@stdlib/stats/iter/mmean","@stdlib/stats/iter/mmin","@stdlib/stats/iter/range"],"@stdlib/stats/iter/msum":["@stdlib/stats/iter/mmean","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/msumabs":["@stdlib/stats/iter/mmeanabs","@stdlib/stats/iter/msum","@stdlib/stats/iter/sum","@stdlib/stats/iter/sumabs"],"@stdlib/stats/iter/msumabs2":["@stdlib/stats/iter/mmeanabs2","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sumabs","@stdlib/stats/iter/sumabs2"],"@stdlib/math/iter/multiply":["@stdlib/math/iter/add","@stdlib/math/iter/divide","@stdlib/math/iter/subtract"],"@stdlib/iter/none":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/iter/none-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/math/iter/nonfibonacci":["@stdlib/math/base/special/nonfibonacci","@stdlib/math/iter/fibonacci"],"@stdlib/iter/nth":["@stdlib/iter/first","@stdlib/iter/last"],"@stdlib/simulate/iter/periodic-sinc":["@stdlib/simulate/iter/sine-wave"],"@stdlib/iter/pipeline":["@stdlib/iter/flow","@stdlib/iter/pipeline-thunk"],"@stdlib/iter/pop":["@stdlib/iter/push","@stdlib/iter/shift","@stdlib/iter/slice"],"@stdlib/stats/iter/prod":["@stdlib/stats/iter/mprod","@stdlib/stats/iter/sum"],"@stdlib/simulate/iter/pulse":["@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/push":["@stdlib/iter/concat","@stdlib/iter/unshift"],"@stdlib/stats/iter/range":["@stdlib/stats/iter/max","@stdlib/stats/iter/mean","@stdlib/stats/iter/min","@stdlib/stats/iter/mrange"],"@stdlib/iter/reject":["@stdlib/iter/filter","@stdlib/iter/map"],"@stdlib/iter/replicate":["@stdlib/iter/replicate-by"],"@stdlib/iter/replicate-by":["@stdlib/iter/replicate"],"@stdlib/simulate/iter/sawtooth-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/shift":["@stdlib/iter/pop","@stdlib/iter/slice","@stdlib/iter/unshift"],"@stdlib/simulate/iter/sine-wave":["@stdlib/simulate/iter/cosine-wave","@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/square-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/iter/slice":["@stdlib/iter/first","@stdlib/iter/head"],"@stdlib/iter/some":["@stdlib/iter/any","@stdlib/iter/every","@stdlib/iter/for-each","@stdlib/iter/none","@stdlib/iter/some-by"],"@stdlib/iter/some-by":["@stdlib/iter/any-by","@stdlib/iter/every-by","@stdlib/iter/for-each","@stdlib/iter/none-by","@stdlib/iter/some"],"@stdlib/simulate/iter/square-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/triangle-wave"],"@stdlib/stats/iter/stdev":["@stdlib/stats/iter/mean","@stdlib/stats/iter/variance"],"@stdlib/math/iter/subtract":["@stdlib/math/iter/add","@stdlib/math/iter/divide","@stdlib/math/iter/multiply"],"@stdlib/stats/iter/sum":["@stdlib/stats/iter/mean","@stdlib/stats/iter/msum","@stdlib/stats/iter/prod"],"@stdlib/stats/iter/sumabs":["@stdlib/stats/iter/meanabs","@stdlib/stats/iter/msumabs","@stdlib/stats/iter/sum"],"@stdlib/stats/iter/sumabs2":["@stdlib/stats/iter/meanabs2","@stdlib/stats/iter/msumabs2","@stdlib/stats/iter/sumabs"],"@stdlib/iter/pipeline-thunk":["@stdlib/iter/pipeline"],"@stdlib/simulate/iter/triangle-wave":["@stdlib/simulate/iter/pulse","@stdlib/simulate/iter/sawtooth-wave","@stdlib/simulate/iter/sine-wave","@stdlib/simulate/iter/square-wave"],"@stdlib/iter/union":["@stdlib/iter/intersection","@stdlib/iter/unique"],"@stdlib/iter/unique":["@stdlib/iter/unique-by","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by":["@stdlib/iter/unique","@stdlib/iter/unique-by-hash"],"@stdlib/iter/unique-by-hash":["@stdlib/iter/unique","@stdlib/iter/unique-by"],"@stdlib/iter/unshift":["@stdlib/iter/concat","@stdlib/iter/push","@stdlib/iter/shift"],"@stdlib/stats/iter/variance":["@stdlib/stats/iter/mean","@stdlib/stats/iter/stdev"],"@stdlib/streams/node/join":["@stdlib/streams/node/split"],"@stdlib/stats/kde2d":[],"@stdlib/utils/key-by":["@stdlib/utils/for-each"],"@stdlib/utils/key-by-right":["@stdlib/utils/for-each-right","@stdlib/utils/key-by"],"@stdlib/utils/keys-in":["@stdlib/utils/entries-in","@stdlib/utils/keys","@stdlib/utils/values-in"],"@stdlib/stats/kruskal-test":[],"@stdlib/stats/kstest":[],"@stdlib/nlp/lda":[],"@stdlib/utils/linked-list":["@stdlib/utils/doubly-linked-list","@stdlib/utils/stack"],"@stdlib/math/utils/linspace":["@stdlib/math/utils/incrspace","@stdlib/math/utils/logspace"],"@stdlib/datasets/liu-negative-opinion-words-en":["@stdlib/datasets/liu-positive-opinion-words-en"],"@stdlib/datasets/liu-positive-opinion-words-en":["@stdlib/datasets/liu-negative-opinion-words-en"],"@stdlib/constants/math/float64-ln-half":[],"@stdlib/constants/math/float64-ln-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/constants/math/float64-ln-sqrt-two-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/constants/math/float64-ln-two-pi":["@stdlib/constants/math/float64-two-pi"],"@stdlib/constants/math/float64-ln-two":["@stdlib/constants/math/float64-ln-ten"],"@stdlib/constants/math/float64-ln-ten":["@stdlib/constants/math/float64-ln-two"],"@stdlib/constants/math/float64-log2-e":["@stdlib/constants/math/float64-e","@stdlib/constants/math/float64-log10-e"],"@stdlib/constants/math/float64-log10-e":["@stdlib/constants/math/float64-e","@stdlib/constants/math/float64-log2-e"],"@stdlib/math/utils/logspace":["@stdlib/math/utils/incrspace","@stdlib/math/utils/linspace"],"@stdlib/string/lowercase":["@stdlib/string/uncapitalize","@stdlib/string/uppercase"],"@stdlib/utils/lowercase-keys":["@stdlib/utils/uncapitalize-keys","@stdlib/utils/uppercase-keys"],"@stdlib/stats/lowess":[],"@stdlib/string/left-pad":["@stdlib/string/pad","@stdlib/string/right-pad"],"@stdlib/string/left-trim":["@stdlib/string/trim","@stdlib/string/right-trim"],"@stdlib/datasets/male-first-names-en":["@stdlib/datasets/female-first-names-en"],"@stdlib/utils/map-function":["@stdlib/utils/async/map-function"],"@stdlib/utils/async/map-function":["@stdlib/utils/map-function"],"@stdlib/utils/map-keys":["@stdlib/utils/map-values"],"@stdlib/utils/async/map-keys":["@stdlib/utils/map-keys","@stdlib/utils/async/map-values"],"@stdlib/utils/map-values":["@stdlib/utils/map-keys","@stdlib/utils/omit-by","@stdlib/utils/pick-by"],"@stdlib/utils/async/map-values":["@stdlib/utils/async/map-keys","@stdlib/utils/map-values"],"@stdlib/constants/array/max-array-length":["@stdlib/constants/array/max-typed-array-length"],"@stdlib/constants/array/max-typed-array-length":["@stdlib/constants/array/max-array-length"],"@stdlib/utils/memoize":[],"@stdlib/utils/merge":["@stdlib/utils/copy"],"@stdlib/constants/time/milliseconds-in-day":[],"@stdlib/constants/time/milliseconds-in-hour":[],"@stdlib/constants/time/milliseconds-in-minute":[],"@stdlib/constants/time/milliseconds-in-second":[],"@stdlib/constants/time/milliseconds-in-week":[],"@stdlib/datasets/minard-napoleons-march":[],"@stdlib/constants/time/minutes-in-day":[],"@stdlib/constants/time/minutes-in-hour":[],"@stdlib/constants/time/minutes-in-week":[],"@stdlib/time/minutes-in-month":["@stdlib/time/minutes-in-year"],"@stdlib/time/minutes-in-year":["@stdlib/time/minutes-in-month"],"@stdlib/datasets/moby-dick":[],"@stdlib/datasets/month-names-en":[],"@stdlib/constants/time/months-in-year":[],"@stdlib/utils/move-property":[],"@stdlib/utils/named-typed-tuple":["@stdlib/array/typed"],"@stdlib/utils/native-class":["@stdlib/utils/constructor-name","@stdlib/utils/type-of"],"@stdlib/ndarray/ctor":["@stdlib/ndarray/array"],"@stdlib/ndarray/casting-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/array/typed-dtypes"],"@stdlib/ndarray/index-modes":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/memoized-ctor":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/min-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/next-dtype":["@stdlib/ndarray/dtypes","@stdlib/ndarray/promotion-rules","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/orders":["@stdlib/ndarray/array","@stdlib/ndarray/ctor"],"@stdlib/ndarray/promotion-rules":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/ndarray/safe-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/same-kind-casts"],"@stdlib/ndarray/same-kind-casts":["@stdlib/ndarray/casting-modes","@stdlib/ndarray/dtypes","@stdlib/ndarray/safe-casts"],"@stdlib/datasets/nightingales-rose":[],"@stdlib/constants/math/float64-ninf":["@stdlib/constants/math/float16-ninf","@stdlib/constants/math/float32-ninf","@stdlib/constants/math/float64-pinf"],"@stdlib/process/node-version":[],"@stdlib/utils/none":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/some"],"@stdlib/utils/none-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/none-by-right","@stdlib/utils/some-by"],"@stdlib/utils/async/none-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/none-by","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by"],"@stdlib/utils/none-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none","@stdlib/utils/none-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/none-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by","@stdlib/utils/none-by-right","@stdlib/utils/async/some-by-right"],"@stdlib/utils/nonenumerable-properties":["@stdlib/utils/enumerable-properties","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/nonenumerable-properties-in":["@stdlib/utils/enumerable-properties-in","@stdlib/utils/inherited-nonenumerable-properties","@stdlib/utils/nonenumerable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/nonenumerable-property-names":["@stdlib/utils/keys","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/nonenumerable-property-names-in":["@stdlib/utils/keys-in","@stdlib/utils/inherited-nonenumerable-property-names","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in"],"@stdlib/utils/nonenumerable-property-symbols":["@stdlib/utils/enumerable-property-symbols","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/nonenumerable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/nonenumerable-property-symbols-in":["@stdlib/utils/enumerable-property-symbols-in","@stdlib/utils/inherited-nonenumerable-property-symbols","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/nonenumerable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/utils/noop":[],"@stdlib/time/now":[],"@stdlib/os/num-cpus":[],"@stdlib/number/ctor":[],"@stdlib/utils/entries":["@stdlib/utils/entries-in","@stdlib/utils/from-entries","@stdlib/utils/keys","@stdlib/utils/values"],"@stdlib/utils/entries-in":["@stdlib/utils/entries","@stdlib/utils/from-entries","@stdlib/utils/keys-in","@stdlib/utils/values-in"],"@stdlib/utils/from-entries":["@stdlib/utils/entries"],"@stdlib/utils/object-inverse":["@stdlib/utils/object-inverse-by"],"@stdlib/utils/object-inverse-by":["@stdlib/utils/object-inverse"],"@stdlib/utils/keys":["@stdlib/utils/entries","@stdlib/utils/keys-in","@stdlib/utils/values"],"@stdlib/utils/values":["@stdlib/utils/entries","@stdlib/utils/keys"],"@stdlib/utils/values-in":["@stdlib/utils/entries-in","@stdlib/utils/keys-in","@stdlib/utils/values"],"@stdlib/utils/omit":["@stdlib/utils/omit-by"],"@stdlib/utils/omit-by":["@stdlib/utils/omit"],"@stdlib/ml/online-binary-classification":["@stdlib/ml/online-sgd-regression"],"@stdlib/ml/online-sgd-regression":["@stdlib/ml/online-binary-classification"],"@stdlib/utils/open-url":[],"@stdlib/datasets/pace-boston-house-prices":["@stdlib/datasets/harrison-boston-house-prices","@stdlib/datasets/harrison-boston-house-prices-corrected"],"@stdlib/string/pad":["@stdlib/string/left-pad","@stdlib/string/right-pad"],"@stdlib/utils/papply":["@stdlib/utils/papply-right"],"@stdlib/utils/papply-right":["@stdlib/utils/papply"],"@stdlib/utils/parallel":[],"@stdlib/utils/parse-json":[],"@stdlib/constants/string/path-delimiter":["@stdlib/constants/string/path-delimiter-posix","@stdlib/constants/string/path-delimiter-win32"],"@stdlib/constants/string/path-delimiter-posix":["@stdlib/constants/string/path-delimiter","@stdlib/constants/string/path-delimiter-win32"],"@stdlib/constants/string/path-delimiter-win32":["@stdlib/constants/string/path-delimiter","@stdlib/constants/string/path-delimiter-posix"],"@stdlib/constants/string/path-sep":["@stdlib/constants/string/path-sep-posix","@stdlib/constants/string/path-sep-win32"],"@stdlib/constants/string/path-sep-posix":["@stdlib/constants/string/path-sep","@stdlib/constants/string/path-sep-win32"],"@stdlib/constants/string/path-sep-win32":["@stdlib/constants/string/path-sep","@stdlib/constants/string/path-sep-posix"],"@stdlib/stats/pcorrtest":[],"@stdlib/string/percent-encode":[],"@stdlib/constants/math/float64-phi":[],"@stdlib/constants/math/float64-pi":["@stdlib/constants/math/float64-two-pi"],"@stdlib/constants/math/float64-pi-squared":["@stdlib/constants/math/float64-pi"],"@stdlib/utils/pick":["@stdlib/utils/pick-by"],"@stdlib/utils/pick-by":["@stdlib/utils/pick"],"@stdlib/constants/math/float64-pinf":["@stdlib/constants/math/float64-ninf"],"@stdlib/namespace/pkg2alias":["@stdlib/namespace/alias2pkg","@stdlib/namespace/aliases","@stdlib/namespace/pkg2related"],"@stdlib/namespace/pkg2related":["@stdlib/namespace/alias2related","@stdlib/namespace/aliases","@stdlib/namespace/pkg2alias"],"@stdlib/os/platform":["@stdlib/os/arch"],"@stdlib/plot":["@stdlib/plot/ctor"],"@stdlib/plot/ctor":["@stdlib/plot"],"@stdlib/utils/pluck":["@stdlib/utils/deep-pluck","@stdlib/utils/pick"],"@stdlib/utils/pop":["@stdlib/utils/push","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/utils/prepend":["@stdlib/utils/append","@stdlib/utils/unshift"],"@stdlib/utils/properties":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/properties-in":["@stdlib/utils/define-properties","@stdlib/utils/inherited-properties","@stdlib/utils/properties","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-descriptor":["@stdlib/assert/has-own-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors"],"@stdlib/utils/property-descriptor-in":["@stdlib/assert/has-property","@stdlib/utils/define-property","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in"],"@stdlib/utils/property-descriptors":["@stdlib/utils/define-property","@stdlib/utils/define-properties","@stdlib/utils/property-descriptor","@stdlib/utils/property-descriptors-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols"],"@stdlib/utils/property-descriptors-in":["@stdlib/utils/define-properties","@stdlib/utils/property-descriptor-in","@stdlib/utils/property-descriptors","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-names":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names","@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/utils/property-names-in":["@stdlib/utils/keys","@stdlib/utils/nonenumerable-property-names-in","@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols":["@stdlib/utils/property-names","@stdlib/utils/property-symbols-in"],"@stdlib/utils/property-symbols-in":["@stdlib/utils/property-names-in","@stdlib/utils/property-symbols"],"@stdlib/proxy/ctor":[],"@stdlib/utils/push":["@stdlib/utils/pop","@stdlib/utils/shift","@stdlib/utils/unshift"],"@stdlib/time/quarter-of-year":["@stdlib/time/day-of-year"],"@stdlib/random/iter/arcsine":["@stdlib/random/base/arcsine"],"@stdlib/random/iter/bernoulli":["@stdlib/random/base/bernoulli"],"@stdlib/random/iter/beta":["@stdlib/random/base/beta"],"@stdlib/random/iter/betaprime":["@stdlib/random/base/betaprime"],"@stdlib/random/iter/binomial":["@stdlib/random/base/binomial"],"@stdlib/random/iter/box-muller":["@stdlib/random/base/box-muller"],"@stdlib/random/iter/cauchy":["@stdlib/random/base/cauchy"],"@stdlib/random/iter/chi":["@stdlib/random/base/chi"],"@stdlib/random/iter/chisquare":["@stdlib/random/base/chisquare"],"@stdlib/random/iter/cosine":["@stdlib/random/base/cosine"],"@stdlib/random/iter/discrete-uniform":["@stdlib/random/base/discrete-uniform"],"@stdlib/random/iter/erlang":["@stdlib/random/base/erlang"],"@stdlib/random/iter/exponential":["@stdlib/random/base/exponential"],"@stdlib/random/iter/f":["@stdlib/random/base/f"],"@stdlib/random/iter/frechet":["@stdlib/random/base/frechet"],"@stdlib/random/iter/gamma":["@stdlib/random/base/gamma"],"@stdlib/random/iter/geometric":["@stdlib/random/base/geometric"],"@stdlib/random/iter/gumbel":["@stdlib/random/base/gumbel"],"@stdlib/random/iter/hypergeometric":["@stdlib/random/base/hypergeometric"],"@stdlib/random/iter/improved-ziggurat":["@stdlib/random/base/improved-ziggurat"],"@stdlib/random/iter/invgamma":["@stdlib/random/base/invgamma"],"@stdlib/random/iter/kumaraswamy":["@stdlib/random/base/kumaraswamy"],"@stdlib/random/iter/laplace":["@stdlib/random/base/laplace"],"@stdlib/random/iter/levy":["@stdlib/random/base/levy"],"@stdlib/random/iter/logistic":["@stdlib/random/base/logistic"],"@stdlib/random/iter/lognormal":["@stdlib/random/base/lognormal"],"@stdlib/random/iter/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd","@stdlib/random/iter/mt19937","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/minstd","@stdlib/random/iter/minstd-shuffle","@stdlib/random/iter/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/negative-binomial":["@stdlib/random/base/negative-binomial"],"@stdlib/random/iter/normal":["@stdlib/random/base/normal"],"@stdlib/random/iter/pareto-type1":["@stdlib/random/base/pareto-type1"],"@stdlib/random/iter/poisson":["@stdlib/random/base/poisson"],"@stdlib/random/iter/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randu"],"@stdlib/random/iter/randn":["@stdlib/random/base/randn"],"@stdlib/random/iter/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randi"],"@stdlib/random/iter/rayleigh":["@stdlib/random/base/rayleigh"],"@stdlib/random/iter/t":["@stdlib/random/base/t"],"@stdlib/random/iter/triangular":["@stdlib/random/base/triangular"],"@stdlib/random/iter/uniform":["@stdlib/random/base/uniform"],"@stdlib/random/iter/weibull":["@stdlib/random/base/weibull"],"@stdlib/random/streams/arcsine":["@stdlib/random/base/arcsine","@stdlib/random/iter/arcsine"],"@stdlib/random/streams/bernoulli":["@stdlib/random/base/bernoulli","@stdlib/random/iter/bernoulli"],"@stdlib/random/streams/beta":["@stdlib/random/base/beta","@stdlib/random/iter/beta"],"@stdlib/random/streams/betaprime":["@stdlib/random/base/betaprime","@stdlib/random/iter/betaprime"],"@stdlib/random/streams/binomial":["@stdlib/random/base/binomial","@stdlib/random/iter/binomial"],"@stdlib/random/streams/box-muller":["@stdlib/random/base/box-muller","@stdlib/random/iter/box-muller","@stdlib/random/streams/improved-ziggurat","@stdlib/random/streams/randn"],"@stdlib/random/streams/cauchy":["@stdlib/random/base/cauchy","@stdlib/random/iter/cauchy"],"@stdlib/random/streams/chi":["@stdlib/random/base/chi","@stdlib/random/iter/chi"],"@stdlib/random/streams/chisquare":["@stdlib/random/base/chisquare","@stdlib/random/iter/chisquare"],"@stdlib/random/streams/cosine":["@stdlib/random/base/cosine","@stdlib/random/iter/cosine"],"@stdlib/random/streams/discrete-uniform":["@stdlib/random/base/discrete-uniform","@stdlib/random/iter/discrete-uniform"],"@stdlib/random/streams/erlang":["@stdlib/random/base/erlang","@stdlib/random/iter/erlang"],"@stdlib/random/streams/exponential":["@stdlib/random/base/exponential","@stdlib/random/iter/exponential"],"@stdlib/random/streams/f":["@stdlib/random/base/f","@stdlib/random/iter/f"],"@stdlib/random/streams/gamma":["@stdlib/random/base/gamma","@stdlib/random/iter/gamma"],"@stdlib/random/streams/geometric":["@stdlib/random/base/geometric","@stdlib/random/iter/geometric"],"@stdlib/random/streams/gumbel":["@stdlib/random/base/gumbel","@stdlib/random/iter/gumbel"],"@stdlib/random/streams/improved-ziggurat":["@stdlib/random/base/improved-ziggurat","@stdlib/random/iter/improved-ziggurat","@stdlib/random/streams/box-muller","@stdlib/random/streams/randn"],"@stdlib/random/streams/invgamma":["@stdlib/random/base/invgamma","@stdlib/random/iter/invgamma"],"@stdlib/random/streams/kumaraswamy":["@stdlib/random/base/kumaraswamy","@stdlib/random/iter/kumaraswamy"],"@stdlib/random/streams/laplace":["@stdlib/random/base/laplace","@stdlib/random/iter/laplace"],"@stdlib/random/streams/levy":["@stdlib/random/base/levy","@stdlib/random/iter/levy"],"@stdlib/random/streams/logistic":["@stdlib/random/base/logistic","@stdlib/random/iter/logistic"],"@stdlib/random/streams/lognormal":["@stdlib/random/base/lognormal","@stdlib/random/iter/lognormal"],"@stdlib/random/streams/minstd":["@stdlib/random/base/minstd","@stdlib/random/iter/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/minstd-shuffle":["@stdlib/random/base/minstd-shuffle","@stdlib/random/iter/minstd-shuffle","@stdlib/random/streams/minstd","@stdlib/random/streams/mt19937","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/mt19937":["@stdlib/random/base/mt19937","@stdlib/random/iter/mt19937","@stdlib/random/streams/minstd","@stdlib/random/streams/minstd-shuffle","@stdlib/random/streams/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/negative-binomial":["@stdlib/random/base/negative-binomial","@stdlib/random/iter/negative-binomial"],"@stdlib/random/streams/normal":["@stdlib/random/base/normal","@stdlib/random/iter/normal"],"@stdlib/random/streams/pareto-type1":["@stdlib/random/base/pareto-type1","@stdlib/random/iter/pareto-type1"],"@stdlib/random/streams/poisson":["@stdlib/random/base/poisson","@stdlib/random/iter/poisson"],"@stdlib/random/streams/randi":["@stdlib/random/base/randi","@stdlib/random/iter/randi","@stdlib/random/streams/randu"],"@stdlib/random/streams/randn":["@stdlib/random/base/randn","@stdlib/random/iter/randn","@stdlib/random/streams/box-muller","@stdlib/random/streams/improved-ziggurat"],"@stdlib/random/streams/randu":["@stdlib/random/base/randu","@stdlib/random/iter/randu","@stdlib/random/streams/randi"],"@stdlib/random/streams/rayleigh":["@stdlib/random/base/rayleigh","@stdlib/random/iter/rayleigh"],"@stdlib/random/streams/t":["@stdlib/random/base/t","@stdlib/random/iter/t"],"@stdlib/random/streams/uniform":["@stdlib/random/base/uniform","@stdlib/random/iter/uniform"],"@stdlib/random/streams/weibull":["@stdlib/random/base/weibull","@stdlib/random/iter/weibull"],"@stdlib/stats/ranks":[],"@stdlib/regexp/basename":["@stdlib/regexp/basename-posix","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-posix":["@stdlib/regexp/basename","@stdlib/regexp/basename-windows"],"@stdlib/regexp/basename-windows":["@stdlib/regexp/basename","@stdlib/regexp/basename-posix"],"@stdlib/regexp/color-hexadecimal":[],"@stdlib/regexp/decimal-number":[],"@stdlib/regexp/dirname":["@stdlib/regexp/dirname-posix","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-posix":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-windows","@stdlib/utils/dirname"],"@stdlib/regexp/dirname-windows":["@stdlib/regexp/dirname","@stdlib/regexp/dirname-posix","@stdlib/utils/dirname"],"@stdlib/regexp/eol":[],"@stdlib/regexp/extended-length-path":[],"@stdlib/regexp/extname":["@stdlib/regexp/extname-posix","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-posix":["@stdlib/regexp/extname","@stdlib/regexp/extname-windows","@stdlib/utils/extname"],"@stdlib/regexp/extname-windows":["@stdlib/regexp/extname","@stdlib/regexp/extname-posix","@stdlib/utils/extname"],"@stdlib/regexp/filename":["@stdlib/regexp/filename-posix","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-posix":["@stdlib/regexp/filename","@stdlib/regexp/filename-windows"],"@stdlib/regexp/filename-windows":["@stdlib/regexp/filename","@stdlib/regexp/filename-posix"],"@stdlib/regexp/function-name":["@stdlib/utils/function-name"],"@stdlib/regexp/native-function":["@stdlib/regexp/function-name","@stdlib/utils/function-name"],"@stdlib/regexp/regexp":["@stdlib/utils/regexp-from-string"],"@stdlib/regexp/unc-path":["@stdlib/assert/is-unc-path"],"@stdlib/regexp/utf16-surrogate-pair":["@stdlib/regexp/utf16-unpaired-surrogate"],"@stdlib/regexp/utf16-unpaired-surrogate":["@stdlib/regexp/utf16-surrogate-pair"],"@stdlib/regexp/whitespace":["@stdlib/assert/is-whitespace"],"@stdlib/fs/read-dir":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/fs/read-file":["@stdlib/fs/exists","@stdlib/fs/read-dir","@stdlib/fs/read-json","@stdlib/fs/write-file"],"@stdlib/fs/read-file-list":[],"@stdlib/fs/read-json":["@stdlib/fs/read-file"],"@stdlib/fs/read-wasm":["@stdlib/fs/read-file"],"@stdlib/complex/real":["@stdlib/complex/imag","@stdlib/complex/reim"],"@stdlib/utils/real-max":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/real-min":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/utils/reduce":["@stdlib/utils/for-each","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/async/reduce":["@stdlib/utils/async/for-each","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/reduce-right":["@stdlib/utils/for-each-right","@stdlib/utils/reduce","@stdlib/utils/async/reduce-right"],"@stdlib/utils/async/reduce-right":["@stdlib/utils/async/for-each-right","@stdlib/utils/async/reduce","@stdlib/utils/reduce-right"],"@stdlib/utils/regexp-from-string":[],"@stdlib/complex/reim":["@stdlib/complex/imag","@stdlib/complex/real"],"@stdlib/string/remove-first":["@stdlib/string/remove-last"],"@stdlib/string/remove-last":["@stdlib/string/remove-first"],"@stdlib/string/remove-punctuation":[],"@stdlib/string/remove-utf8-bom":[],"@stdlib/string/remove-words":[],"@stdlib/fs/rename":["@stdlib/fs/exists","@stdlib/fs/read-file","@stdlib/fs/write-file","@stdlib/fs/unlink"],"@stdlib/utils/reorder-arguments":["@stdlib/utils/reverse-arguments"],"@stdlib/string/repeat":["@stdlib/string/pad"],"@stdlib/string/replace":[],"@stdlib/utils/escape-regexp-string":[],"@stdlib/fs/resolve-parent-path":[],"@stdlib/utils/reverse-arguments":["@stdlib/utils/reorder-arguments"],"@stdlib/string/reverse":[],"@stdlib/random/base/reviver":[],"@stdlib/buffer/reviver":["@stdlib/buffer/to-json"],"@stdlib/complex/reviver":["@stdlib/complex/float64","@stdlib/complex/float32","@stdlib/complex/reviver-float64","@stdlib/complex/reviver-float32"],"@stdlib/complex/reviver-float32":["@stdlib/complex/float32","@stdlib/complex/reviver-float64","@stdlib/complex/reviver"],"@stdlib/complex/reviver-float64":["@stdlib/complex/float64","@stdlib/complex/reviver-float32","@stdlib/complex/reviver"],"@stdlib/error/reviver":["@stdlib/error/to-json"],"@stdlib/array/reviver":["@stdlib/array/to-json"],"@stdlib/string/right-pad":["@stdlib/string/left-pad","@stdlib/string/pad"],"@stdlib/string/right-trim":["@stdlib/string/left-trim","@stdlib/string/trim"],"@stdlib/utils/safe-int-max":["@stdlib/utils/safe-int-min","@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/utils/safe-int-min":["@stdlib/utils/safe-int-max","@stdlib/utils/real-min","@stdlib/utils/type-min"],"@stdlib/random/sample":[],"@stdlib/datasets/savoy-stopwords-fin":[],"@stdlib/datasets/savoy-stopwords-fr":[],"@stdlib/datasets/savoy-stopwords-ger":[],"@stdlib/datasets/savoy-stopwords-it":[],"@stdlib/datasets/savoy-stopwords-por":[],"@stdlib/datasets/savoy-stopwords-sp":[],"@stdlib/datasets/savoy-stopwords-swe":[],"@stdlib/constants/time/seconds-in-day":[],"@stdlib/constants/time/seconds-in-hour":[],"@stdlib/constants/time/seconds-in-minute":[],"@stdlib/constants/time/seconds-in-week":[],"@stdlib/time/seconds-in-month":["@stdlib/time/seconds-in-year"],"@stdlib/time/seconds-in-year":["@stdlib/time/seconds-in-month"],"@stdlib/utils/define-configurable-read-only-property":["@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-configurable-read-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-configurable-read-write-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-write-only-accessor","@stdlib/utils/define-property","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-configurable-write-only-accessor":["@stdlib/utils/define-configurable-read-only-property","@stdlib/utils/define-configurable-read-only-accessor","@stdlib/utils/define-configurable-read-write-accessor","@stdlib/utils/define-property","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-memoized-read-only-property":["@stdlib/utils/define-memoized-property","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-property":["@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-property":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-property"],"@stdlib/utils/define-nonenumerable-read-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-only-accessor"],"@stdlib/utils/define-nonenumerable-read-write-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-write-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/utils/define-nonenumerable-write-only-accessor":["@stdlib/utils/define-nonenumerable-property","@stdlib/utils/define-nonenumerable-read-only-accessor","@stdlib/utils/define-nonenumerable-read-only-property","@stdlib/utils/define-nonenumerable-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-property":["@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-write-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-read-write-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-write-only-accessor"],"@stdlib/utils/define-write-only-accessor":["@stdlib/utils/define-read-only-property","@stdlib/utils/define-read-only-accessor","@stdlib/utils/define-read-write-accessor"],"@stdlib/array/shared-buffer":["@stdlib/buffer/ctor","@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/utils/shift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/unshift"],"@stdlib/random/shuffle":["@stdlib/random/sample"],"@stdlib/utils/size-of":["@stdlib/utils/real-max","@stdlib/utils/type-max"],"@stdlib/utils/some":["@stdlib/utils/any","@stdlib/utils/every","@stdlib/utils/for-each","@stdlib/utils/none","@stdlib/utils/some-by"],"@stdlib/utils/some-by":["@stdlib/utils/any-by","@stdlib/utils/every-by","@stdlib/utils/for-each","@stdlib/utils/none-by","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/utils/async/some-by":["@stdlib/utils/async/any-by","@stdlib/utils/async/every-by","@stdlib/utils/async/for-each","@stdlib/utils/async/none-by","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/some-by-right":["@stdlib/utils/any-by-right","@stdlib/utils/every-by-right","@stdlib/utils/for-each-right","@stdlib/utils/none-by-right","@stdlib/utils/some-by","@stdlib/utils/async/some-by-right"],"@stdlib/utils/async/some-by-right":["@stdlib/utils/async/any-by-right","@stdlib/utils/async/every-by-right","@stdlib/utils/async/for-each-right","@stdlib/utils/async/none-by-right","@stdlib/utils/async/some-by","@stdlib/utils/some-by-right"],"@stdlib/datasets/sotu":[],"@stdlib/datasets/spache-revised":[],"@stdlib/datasets/spam-assassin":[],"@stdlib/plot/sparklines/base/ctor":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/array/to-sparse-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator","@stdlib/array/to-sparse-iterator-right"],"@stdlib/array/to-sparse-iterator-right":["@stdlib/array/from-iterator","@stdlib/array/to-iterator-right","@stdlib/array/to-sparse-iterator"],"@stdlib/streams/node/split":["@stdlib/streams/node/join"],"@stdlib/constants/math/float64-sqrt-eps":["@stdlib/constants/math/float64-eps"],"@stdlib/constants/math/float64-sqrt-half":["@stdlib/constants/math/float64-ln-half"],"@stdlib/constants/math/float64-sqrt-half-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/constants/math/float64-sqrt-phi":["@stdlib/constants/math/float64-phi"],"@stdlib/constants/math/float64-sqrt-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/constants/math/float64-sqrt-three":[],"@stdlib/constants/math/float64-sqrt-two":["@stdlib/constants/math/float64-ln-two"],"@stdlib/constants/math/float64-sqrt-two-pi":["@stdlib/constants/math/float64-two-pi"],"@stdlib/utils/stack":["@stdlib/utils/fifo"],"@stdlib/string/startcase":["@stdlib/string/lowercase","@stdlib/string/uppercase"],"@stdlib/string/starts-with":["@stdlib/string/ends-with"],"@stdlib/datasets/stopwords-en":[],"@stdlib/array/to-strided-iterator":["@stdlib/array/from-iterator","@stdlib/array/to-iterator"],"@stdlib/streams/node/from-strided-array":["@stdlib/streams/node/from-array"],"@stdlib/buffer/from-string":["@stdlib/buffer/ctor","@stdlib/buffer/from-array","@stdlib/buffer/from-arraybuffer","@stdlib/buffer/from-buffer"],"@stdlib/ndarray/sub2ind":["@stdlib/ndarray/array","@stdlib/ndarray/ctor","@stdlib/ndarray/ind2sub"],"@stdlib/datasets/suthaharan-multi-hop-sensor-network":["@stdlib/datasets/suthaharan-single-hop-sensor-network"],"@stdlib/datasets/suthaharan-single-hop-sensor-network":["@stdlib/datasets/suthaharan-multi-hop-sensor-network"],"@stdlib/symbol/ctor":[],"@stdlib/utils/tabulate":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate-by"],"@stdlib/utils/tabulate-by":["@stdlib/utils/count-by","@stdlib/utils/group-by","@stdlib/utils/tabulate"],"@stdlib/utils/async/tabulate-by":["@stdlib/utils/async/count-by","@stdlib/utils/async/group-by","@stdlib/utils/tabulate-by"],"@stdlib/time/tic":["@stdlib/time/toc"],"@stdlib/utils/timeit":[],"@stdlib/os/tmpdir":["@stdlib/os/configdir","@stdlib/os/homedir"],"@stdlib/time/toc":["@stdlib/time/tic"],"@stdlib/nlp/tokenize":[],"@stdlib/streams/node/transform":[],"@stdlib/string/trim":["@stdlib/string/left-trim","@stdlib/string/pad","@stdlib/string/right-trim"],"@stdlib/utils/try-catch":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/utils/async/try-catch":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/try-function":[],"@stdlib/utils/try-require":[],"@stdlib/utils/try-then":["@stdlib/utils/try-catch","@stdlib/utils/async/try-then"],"@stdlib/utils/async/try-then":["@stdlib/utils/async/try-catch","@stdlib/utils/try-then"],"@stdlib/stats/ttest":["@stdlib/stats/ttest2"],"@stdlib/stats/ttest2":["@stdlib/stats/ttest"],"@stdlib/constants/math/float64-two-pi":["@stdlib/constants/math/float64-pi"],"@stdlib/array/typed":["@stdlib/array/float64","@stdlib/array/float32","@stdlib/array/int32","@stdlib/array/uint32","@stdlib/array/int16","@stdlib/array/uint16","@stdlib/array/int8","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/array/to-json":["@stdlib/array/reviver"],"@stdlib/array/typed-complex-ctors":["@stdlib/array/ctors","@stdlib/array/typed-ctors"],"@stdlib/array/typed-complex-dtypes":["@stdlib/array/dtypes","@stdlib/array/typed-dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/typed-ctors":["@stdlib/array/ctors"],"@stdlib/array/typed-dtypes":["@stdlib/array/dtypes","@stdlib/ndarray/dtypes"],"@stdlib/array/pool":["@stdlib/array/typed"],"@stdlib/utils/type-max":["@stdlib/utils/real-max","@stdlib/utils/type-min"],"@stdlib/utils/type-min":["@stdlib/utils/real-min","@stdlib/utils/type-max"],"@stdlib/utils/type-of":["@stdlib/utils/constructor-name","@stdlib/utils/native-class"],"@stdlib/constants/math/uint8-max":["@stdlib/constants/math/int8-max"],"@stdlib/constants/math/uint8-num-bytes":["@stdlib/constants/math/int8-num-bytes","@stdlib/constants/math/uint16-num-bytes","@stdlib/constants/math/uint32-num-bytes"],"@stdlib/array/uint8":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8c"],"@stdlib/array/uint8c":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint32","@stdlib/array/uint8"],"@stdlib/constants/math/uint16-max":["@stdlib/constants/math/int16-max"],"@stdlib/constants/math/uint16-num-bytes":["@stdlib/constants/math/int16-num-bytes","@stdlib/constants/math/uint32-num-bytes","@stdlib/constants/math/uint8-num-bytes"],"@stdlib/array/uint16":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint32","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/constants/math/uint32-max":["@stdlib/constants/math/int32-max"],"@stdlib/constants/math/uint32-num-bytes":["@stdlib/constants/math/int32-num-bytes","@stdlib/constants/math/uint16-num-bytes","@stdlib/constants/math/uint8-num-bytes"],"@stdlib/array/uint32":["@stdlib/array/buffer","@stdlib/array/float32","@stdlib/array/float64","@stdlib/array/int16","@stdlib/array/int32","@stdlib/array/int8","@stdlib/array/uint16","@stdlib/array/uint8","@stdlib/array/uint8c"],"@stdlib/process/umask":[],"@stdlib/string/uncapitalize":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uncapitalize-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/utils/uncurry":["@stdlib/utils/curry","@stdlib/utils/uncurry-right"],"@stdlib/utils/uncurry-right":["@stdlib/utils/curry","@stdlib/utils/curry-right","@stdlib/utils/uncurry"],"@stdlib/constants/string/unicode-max":["@stdlib/constants/string/unicode-max-bmp"],"@stdlib/constants/string/unicode-max-bmp":["@stdlib/constants/string/unicode-max"],"@stdlib/plot/sparklines/unicode/column":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/line":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/tristate":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/up-down","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/up-down":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/win-loss"],"@stdlib/plot/sparklines/unicode/win-loss":["@stdlib/plot","@stdlib/plot/ctor","@stdlib/plot/sparklines/unicode","@stdlib/plot/sparklines/unicode/column","@stdlib/plot/sparklines/unicode/line","@stdlib/plot/sparklines/unicode/tristate","@stdlib/plot/sparklines/unicode/up-down"],"@stdlib/fs/unlink":["@stdlib/fs/exists"],"@stdlib/utils/unshift":["@stdlib/utils/pop","@stdlib/utils/push","@stdlib/utils/shift"],"@stdlib/utils/until":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/async/until","@stdlib/utils/until-each","@stdlib/utils/while"],"@stdlib/utils/async/until":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/until","@stdlib/utils/async/while"],"@stdlib/utils/until-each":["@stdlib/utils/until-each-right","@stdlib/utils/while-each"],"@stdlib/utils/until-each-right":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/unzip":["@stdlib/utils/zip"],"@stdlib/string/uppercase":["@stdlib/string/capitalize","@stdlib/string/lowercase"],"@stdlib/utils/uppercase-keys":["@stdlib/utils/capitalize-keys","@stdlib/utils/lowercase-keys"],"@stdlib/datasets/us-states-abbr":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names"],"@stdlib/datasets/us-states-capitals":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-capitals-names":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names":["@stdlib/datasets/us-states-abbr","@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-capitals-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/datasets/us-states-names-capitals":["@stdlib/datasets/us-states-capitals","@stdlib/datasets/us-states-names","@stdlib/datasets/us-states-names-capitals"],"@stdlib/string/utf16-to-utf8-array":[],"@stdlib/stats/vartest":["@stdlib/stats/bartlett-test"],"@stdlib/utils/async/series-waterfall":[],"@stdlib/utils/async/while":["@stdlib/utils/async/do-until","@stdlib/utils/async/do-while","@stdlib/utils/async/until","@stdlib/utils/while"],"@stdlib/utils/while-each":["@stdlib/utils/until-each","@stdlib/utils/while-each-right"],"@stdlib/utils/while-each-right":["@stdlib/utils/while-each","@stdlib/utils/until-each-right"],"@stdlib/utils/while":["@stdlib/utils/do-until","@stdlib/utils/do-while","@stdlib/utils/until","@stdlib/utils/async/while","@stdlib/utils/while-each"],"@stdlib/utils/writable-properties":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties-in","@stdlib/utils/properties"],"@stdlib/utils/writable-properties-in":["@stdlib/utils/inherited-writable-properties","@stdlib/utils/writable-properties","@stdlib/utils/properties-in"],"@stdlib/utils/writable-property-names":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-names"],"@stdlib/utils/writable-property-names-in":["@stdlib/utils/inherited-writable-property-names","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-names-in"],"@stdlib/utils/writable-property-symbols":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties","@stdlib/utils/writable-property-names","@stdlib/utils/writable-property-symbols-in","@stdlib/utils/property-symbols"],"@stdlib/utils/writable-property-symbols-in":["@stdlib/utils/inherited-writable-property-symbols","@stdlib/utils/writable-properties-in","@stdlib/utils/writable-property-names-in","@stdlib/utils/writable-property-symbols","@stdlib/utils/property-symbols-in"],"@stdlib/fs/write-file":["@stdlib/fs/exists","@stdlib/fs/read-file"],"@stdlib/utils/zip":["@stdlib/utils/unzip"],"@stdlib/stats/ztest":["@stdlib/stats/ztest2"],"@stdlib/stats/ztest2":["@stdlib/stats/ztest"]}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/datapackage.json b/lib/node_modules/@stdlib/namespace/pkg2related/datapackage.json
new file mode 100644
index 000000000000..b70a4ed791a8
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/datapackage.json
@@ -0,0 +1,58 @@
+{
+ "name": "stdlib-pkg2related",
+ "version": "",
+ "title": "Standard Library Package Names and Related Packages",
+ "description": "A mapping between standard library package names and related packages.",
+ "resources": [
+ {
+ "name": "stdlib-pkg2related-json",
+ "title": "Standard Library Package Names and Related Packages",
+ "description": "A mapping between standard library package names and related packages.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-pkg2related-csv",
+ "title": "Standard Library Package Names and Related Packages",
+ "description": "A mapping between standard library package names and related packages.",
+ "format": "csv",
+ "mediatype": "plain/csv",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.csv",
+ "schema": {
+ "fields": [
+ {
+ "name": "pkg",
+ "title": "Package Name",
+ "description": "Package name.",
+ "type": "string",
+ "format": "default"
+ },
+ {
+ "name": "related",
+ "title": "Related",
+ "description": "Comma-delimited package names.",
+ "type": "string",
+ "format": "default"
+ }
+ ]
+ }
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "stdlib",
+ "namespace",
+ "package",
+ "packages",
+ "pkg",
+ "pkgs",
+ "name",
+ "related"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/docs/repl.txt b/lib/node_modules/@stdlib/namespace/pkg2related/docs/repl.txt
new file mode 100644
index 000000000000..e8b0682f6ad0
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/docs/repl.txt
@@ -0,0 +1,22 @@
+
+{{alias}}( pkg )
+ Returns package names related to a specified package name.
+
+ Parameters
+ ----------
+ pkg: string
+ Package name.
+
+ Returns
+ -------
+ out: Array|null
+ Related package names.
+
+ Examples
+ --------
+ > var v = {{alias}}( '@stdlib/math/base/special/sin' )
+ [...]
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/index.d.ts b/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/index.d.ts
new file mode 100644
index 000000000000..43d339f32923
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/index.d.ts
@@ -0,0 +1,36 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns package names related to a specified package name.
+*
+* @param pkg - package name
+* @returns related package names
+*
+* @example
+* var out = pkg2related( '@stdlib/math/base/special/sin' );
+* // returns [...]
+*/
+declare function pkg2related( pkg: string ): Array | null;
+
+
+// EXPORTS //
+
+export = pkg2related;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/test.ts b/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/test.ts
new file mode 100644
index 000000000000..c35a499a0e63
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 pkg2related = require( './index' );
+
+
+// TESTS //
+
+// The function returns an array of strings or null...
+{
+ pkg2related( 'base.sin' ); // $ExpectType string[] | null
+}
+
+// The compiler throws an error if the function is not provided a string...
+{
+ pkg2related( 5 ); // $ExpectError
+ pkg2related( true ); // $ExpectError
+ pkg2related( false ); // $ExpectError
+ pkg2related( null ); // $ExpectError
+ pkg2related( undefined ); // $ExpectError
+ pkg2related( [] ); // $ExpectError
+ pkg2related( {} ); // $ExpectError
+ pkg2related( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ pkg2related( 'base.sin', 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/docs/usage.txt b/lib/node_modules/@stdlib/namespace/pkg2related/docs/usage.txt
new file mode 100644
index 000000000000..ad9f9c201ee7
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-pkg2related [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/etc/cli_opts.json b/lib/node_modules/@stdlib/namespace/pkg2related/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/examples/index.js b/lib/node_modules/@stdlib/namespace/pkg2related/examples/index.js
new file mode 100644
index 000000000000..370ed08d836e
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var pkg2related = require( './../lib' );
+
+var list;
+var len;
+var idx;
+var pkg;
+var v;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ v = list[ idx ];
+ pkg = alias2pkg( v );
+ console.log( 'alias: %s. related: %s.', v, pkg2related( pkg ).join( ', ' ) );
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/lib/index.js b/lib/node_modules/@stdlib/namespace/pkg2related/lib/index.js
new file mode 100644
index 000000000000..6cffe00b0fbb
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/lib/index.js
@@ -0,0 +1,40 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 package names related to a specified package name.
+*
+* @module @stdlib/namespace/pkg2related
+*
+* @example
+* var pkg2related = require( '@stdlib/namespace/pkg2related' );
+*
+* var v = pkg2related( '@stdlib/math/base/special/sin' );
+* // returns [...]
+*/
+
+// MODULES //
+
+var pkg2related = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = pkg2related;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/lib/main.js b/lib/node_modules/@stdlib/namespace/pkg2related/lib/main.js
new file mode 100644
index 000000000000..b5b18e220ec4
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/lib/main.js
@@ -0,0 +1,54 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var PKG_TO_RELATED = require( './../data/data.json' );
+
+
+// MAIN //
+
+/**
+* Returns package names related to a specified package name.
+*
+* @param {string} pkg - package name
+* @throws {TypeError} must provide a string
+* @returns {(Array|StringArray|null)} related package names
+*
+* @example
+* var v = pkg2related( '@stdlib/math/base/special/sin' );
+* // returns [...]
+*/
+function pkg2related( pkg ) {
+ if ( !isString( pkg ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + pkg + '`.' );
+ }
+ if ( hasOwnProp( PKG_TO_RELATED, pkg ) ) {
+ return PKG_TO_RELATED[ pkg ].slice();
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = pkg2related;
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/package.json b/lib/node_modules/@stdlib/namespace/pkg2related/package.json
new file mode 100644
index 000000000000..f0194c259336
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/package.json
@@ -0,0 +1,71 @@
+{
+ "name": "@stdlib/namespace/pkg2related",
+ "version": "0.0.0",
+ "description": "Return package names related to a specified package name.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-pkg2related": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "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",
+ "standard",
+ "library",
+ "lib",
+ "namespace",
+ "packages",
+ "package",
+ "name",
+ "pkg",
+ "pkgs",
+ "related",
+ "see",
+ "also"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/scripts/build.js b/lib/node_modules/@stdlib/namespace/pkg2related/scripts/build.js
new file mode 100644
index 000000000000..168ce3b1055c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/scripts/build.js
@@ -0,0 +1,99 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var namespace = require( '@stdlib/namespace' );
+var pkg2alias = require( '@stdlib/namespace/pkg2alias' );
+var objectKeys = require( '@stdlib/utils/keys' );
+
+
+// VARIABLES //
+
+var debug = logger( 'namespace:pkg2related:build' );
+
+// Output file paths:
+var OUTPUT_JSON = resolve( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_CSV = resolve( __dirname, '..', 'data', 'data.csv' );
+
+
+// FUNCTIONS //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var related;
+ var alias;
+ var fopts;
+ var keys;
+ var json;
+ var tmp;
+ var csv;
+ var ns;
+ var i;
+ var j;
+
+ debug( 'Extracting namespace package data...' );
+ ns = namespace();
+ json = {};
+ for ( i = 0; i < ns.length; i++ ) {
+ related = ns[ i ].related.slice();
+
+ // Check that each related package actually corresponds to an alias in the namespace, as sometimes packages are added to the `related` field before they are actually created...
+ tmp = [];
+ for ( j = 0; j < related.length; j++ ) {
+ alias = pkg2alias( related[ j ] );
+ if ( alias ) {
+ tmp.push( related[ j ] );
+ } else {
+ console.error( 'WARNING: unable to resolve related package `'+related[j]+'` for `'+ns[i].alias+'`.' ); // eslint-disable-line no-console
+ }
+ }
+ json[ ns[i].path ] = tmp;
+ }
+
+ debug( 'Writing to JSON file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ writeFile( OUTPUT_JSON, JSON.stringify( json ), fopts );
+
+ debug( 'Writing to CSV file...' );
+ fopts = {
+ 'encoding': 'utf8'
+ };
+ keys = objectKeys( json );
+ csv = '';
+ for ( i = 0; i < keys.length; i++ ) {
+ csv += '"' + keys[ i ] + '","' + json[ keys[i] ].join( ',' ) + '"\n'; // Note: ensures trailing newline
+ }
+ writeFile( OUTPUT_CSV, csv, fopts );
+}
+
+
+// MAIN //
+
+main();
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/test/test.cli.js b/lib/node_modules/@stdlib/namespace/pkg2related/test/test.cli.js
new file mode 100644
index 000000000000..ef02c11f51ac
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/test/test.cli.js
@@ -0,0 +1,184 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints related package names', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '@stdlib/math/base/special/sin'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ stdout = stdout.toString().split( '\n' );
+
+ // Greater than 1 in order to include the trailing newline:
+ t.strictEqual( stdout.length > 1, true, 'prints related packages' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
+
+tape( 'if unable to resolve a package name, the command-line interface sets a non-zero exit code', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'fjaldfjadljfeoejreandfljasdfjadsfjs'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.pass( error.message );
+ t.strictEqual( error.code, 1, 'expected exit code' );
+ }
+ t.strictEqual( stdout.toString(), '', 'does not print to` stdout`' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/namespace/pkg2related/test/test.js b/lib/node_modules/@stdlib/namespace/pkg2related/test/test.js
new file mode 100644
index 000000000000..c4984679a92c
--- /dev/null
+++ b/lib/node_modules/@stdlib/namespace/pkg2related/test/test.js
@@ -0,0 +1,95 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( '@stdlib/namespace/aliases' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var DATA = require( './../data/data.json' );
+var pkg2related = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof pkg2related, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if not provided a string', function test( t ) {
+ var values;
+ 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() {
+ pkg2related( value );
+ };
+ }
+});
+
+tape( 'the function returns related package names', function test( t ) {
+ var expected;
+ var actual;
+ var list;
+ var pkg;
+ var i;
+
+ list = aliases();
+ for ( i = 0; i < list.length; i++ ) {
+ pkg = alias2pkg( list[i] );
+ expected = DATA[ pkg ];
+ actual = pkg2related( pkg );
+ t.deepEqual( actual, expected, 'returns expected value for '+list[i] );
+ }
+ t.end();
+});
+
+tape( 'the function returns `null` if provided an unrecognized package name', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ 'adfkaljdfdsafs',
+ 'adklfadjflajdslfjalsdf',
+ 'adflkajdlkfjasdlkfjsadlkfjlasdjflsdjfla'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.strictEqual( pkg2related( values[ i ] ), null, 'returns expected value' );
+ }
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/LICENSE b/lib/node_modules/@stdlib/repl/code-blocks/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/README.md b/lib/node_modules/@stdlib/repl/code-blocks/README.md
index 47e3cd76cfb4..714c2da6d33a 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/README.md
+++ b/lib/node_modules/@stdlib/repl/code-blocks/README.md
@@ -2,7 +2,7 @@
@license Apache-2.0
-Copyright (c) 2018 The Stdlib Authors.
+Copyright (c) 2019 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.
@@ -20,7 +20,7 @@ limitations under the License.
# Examples
-> REPL examples.
+> Return an example associated with a provided alias.
@@ -37,16 +37,23 @@ limitations under the License.
## Usage
```javascript
-var examples = require( '@stdlib/repl/code-blocks' );
+var example = require( '@stdlib/repl/code-blocks' );
```
-#### examples()
+#### example( alias )
-Returns an `object` containing REPL examples as text.
+Returns an example associated with a provided alias.
```javascript
-var o = examples();
-// returns {...}
+var out = example( 'base.sin' );
+// returns
+```
+
+If provided an unrecognized `alias`, the function returns `null`.
+
+```javascript
+var out = example( 'unrecognized_alias_beep_boop_bop_bip' );
+// returns null
```
@@ -72,17 +79,89 @@ var o = examples();
```javascript
-var examples = require( '@stdlib/repl/code-blocks' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var example = require( '@stdlib/repl/code-blocks' );
+
+var list;
+var len;
+var idx;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ console.log( example( list[ idx ] ) );
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-alias-example [options]
+
+Options:
-var o = examples();
-console.log( o );
-// => {...}
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-alias-example 'base.sin'
```
+
+
+
+
@@ -91,10 +170,24 @@ console.log( o );
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/benchmark/benchmark.js b/lib/node_modules/@stdlib/repl/code-blocks/benchmark/benchmark.js
index a18b163b3e43..eb6ea9fd9329 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/benchmark/benchmark.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -21,26 +21,31 @@
// MODULES //
var bench = require( '@stdlib/bench' );
-var isPlainObject = require( '@stdlib/assert/is-plain-object' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var aliases = require( '@stdlib/namespace/aliases' );
var pkg = require( './../package.json' ).name;
-var examples = require( './../lib' );
+var example = require( './../lib' );
// MAIN //
bench( pkg, function benchmark( b ) {
- var o;
+ var values;
+ var v;
var i;
+
+ values = aliases();
+
b.tic();
for ( i = 0; i < b.iterations; i++ ) {
- o = examples();
- if ( typeof o !== 'object' ) {
- b.fail( 'should return an object' );
+ v = example( values[ i%values.length ] );
+ if ( typeof v !== 'string' && v !== null ) {
+ b.fail( 'should return a string or null' );
}
}
b.toc();
- if ( !isPlainObject( o ) ) {
- b.fail( 'should return a plain object' );
+ if ( !isString( v ) && v !== null ) {
+ b.fail( 'should return a string or null' );
}
b.pass( 'benchmark finished' );
b.end();
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/bin/cli b/lib/node_modules/@stdlib/repl/code-blocks/bin/cli
new file mode 100755
index 000000000000..ca5a235b2280
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/bin/cli
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var example = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Print an example corresponding to a provided alias...
+ out = example( args[ 0 ] );
+ if ( out ) {
+ console.log( out ); // eslint-disable-line no-console
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/data/data.csv b/lib/node_modules/@stdlib/repl/code-blocks/data/data.csv
new file mode 100644
index 000000000000..b2bb18f6ba79
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/data/data.csv
@@ -0,0 +1,1885 @@
+AFINN_96,"var list = AFINN_96()\n"
+AFINN_111,"var list = AFINN_111()\n"
+alias2pkg,"var v = alias2pkg( 'base.sin' )\n"
+alias2related,"var v = alias2related( 'base.sin' )\n"
+aliases,"var o = aliases()\n"
+allocUnsafe,"var buf = allocUnsafe( 100 )\n"
+anova1,"var x = [1, 3, 5, 2, 4, 6, 8, 7, 10, 11, 12, 15];\nvar f = [\n'control', 'treatA', 'treatB', 'treatC', 'control',\n'treatA', 'treatB', 'treatC', 'control', 'treatA', 'treatB', 'treatC'\n];\nvar out = anova1( x, f )\n"
+ANSCOMBES_QUARTET,"var d = ANSCOMBES_QUARTET()\n"
+any,"var arr = [ 0, 0, 0, 0, 1 ];\nvar bool = any( arr )\n"
+anyBy,"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, 3, 4, -1 ];\nvar bool = anyBy( arr, negative )\n"
+anyByAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n"
+anyByRight,"function negative( v ) { return ( v < 0 ); };\nvar arr = [ -1, 1, 2, 3, 4 ];\nvar bool = anyByRight( arr, negative )\n"
+anyByRightAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n"
+APERY,"APERY\n"
+append,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = append( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = append( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 0 };\narr = append( arr, [ 1.0, 2.0 ] )\n"
+ARCH,"ARCH\n"
+argumentFunction,"var argn = argumentFunction( 1 );\nvar v = argn( 3.14, -3.14, 0.0 )\nv = argn( -1.0, -0.0, 1.0 )\nv = argn( 'beep', 'boop', 'bop' )\nv = argn( 'beep' )\n"
+ARGV,"var execPath = ARGV[ 0 ]\n"
+array,"\n// Create a 2x2 matrix:\nvar arr = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n"
+array2buffer,"var buf = array2buffer( [ 1, 2, 3, 4 ] )\n"
+array2iterator,"var it = array2iterator( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n"
+array2iteratorRight,"var it = array2iteratorRight( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n"
+ArrayBuffer,"var buf = new ArrayBuffer( 5 )\n"
+arraybuffer2buffer,"var ab = new ArrayBuffer( 10 )\nvar buf = arraybuffer2buffer( ab )\nvar len = buf.length\nbuf = arraybuffer2buffer( ab, 2, 6 )\nlen = buf.length\n"
+arrayCtors,"var ctor = arrayCtors( 'float64' )\nctor = arrayCtors( 'float' )\n"
+arrayDataType,"var arr = new Float64Array( 10 );\nvar dt = arrayDataType( arr )\ndt = arrayDataType( 'beep' )\n"
+arrayDataTypes,"var out = arrayDataTypes()\n"
+arrayMinDataType,"var dt = arrayMinDataType( 3.141592653589793 )\ndt = arrayMinDataType( 3 )\ndt = arrayMinDataType( -3 )\ndt = arrayMinDataType( '-3' )\n"
+arrayNextDataType,"var out = arrayNextDataType( 'float32' )\n"
+arrayPromotionRules,"var out = arrayPromotionRules( 'float32', 'int32' )\n"
+arraySafeCasts,"var out = arraySafeCasts( 'float32' )\n"
+arraySameKindCasts,"var out = arraySameKindCasts( 'float32' )\n"
+arrayShape,"var out = arrayShape( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] )\n"
+arrayStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = arrayStream( [ 1, 2, 3 ] );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+arrayview2iterator,"var it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3 );\nvar v = it.next().value\nv = it.next().value\n"
+arrayview2iteratorRight,"var it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3 );\nvar v = it.next().value\nv = it.next().value\n"
+AsyncIteratorSymbol,"var s = AsyncIteratorSymbol\n"
+bartlettTest,"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = bartlettTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = bartlettTest( arr, { 'groups': groups })\n"
+base.abs,"var y = base.abs( -1.0 )\ny = base.abs( 2.0 )\ny = base.abs( 0.0 )\ny = base.abs( -0.0 )\ny = base.abs( NaN )\n"
+base.abs2,"var y = base.abs2( -1.0 )\ny = base.abs2( 2.0 )\ny = base.abs2( 0.0 )\ny = base.abs2( -0.0 )\ny = base.abs2( NaN )\n"
+base.absdiff,"var d = base.absdiff( 2.0, 5.0 )\nd = base.absdiff( -1.0, 3.14 )\nd = base.absdiff( 10.1, -2.05 )\nd = base.absdiff( -0.0, 0.0 )\nd = base.absdiff( NaN, 5.0 )\nd = base.absdiff( PINF, NINF )\nd = base.absdiff( PINF, PINF )\n"
+base.absInt32,"var v = base.absInt32( -1|0 )\nv = base.absInt32( 2|0 )\nv = base.absInt32( 0|0 )\n"
+base.acos,"var y = base.acos( 1.0 )\ny = base.acos( 0.707 )\ny = base.acos( NaN )\n"
+base.acosh,"var y = base.acosh( 1.0 )\ny = base.acosh( 2.0 )\ny = base.acosh( NaN )\n"
+base.acoth,"var y = base.acoth( 2.0 )\ny = base.acoth( 0.0 )\ny = base.acoth( 0.5 )\ny = base.acoth( 1.0 )\ny = base.acoth( NaN )\n"
+base.acovercos,"var y = base.acovercos( -1.5 )\ny = base.acovercos( -0.0 )\n"
+base.acoversin,"var y = base.acoversin( 1.5 )\ny = base.acoversin( 0.0 )\n"
+base.ahavercos,"var y = base.ahavercos( 0.5 )\ny = base.ahavercos( 0.0 )\n"
+base.ahaversin,"var y = base.ahaversin( 0.5 )\ny = base.ahaversin( 0.0 )\n"
+base.asin,"var y = base.asin( 0.0 )\ny = base.asin( PI/2.0 )\ny = base.asin( -PI/6.0 )\ny = base.asin( NaN )\n"
+base.asinh,"var y = base.asinh( 0.0 )\ny = base.asinh( 2.0 )\ny = base.asinh( -2.0 )\ny = base.asinh( NaN )\ny = base.asinh( NINF )\ny = base.asinh( PINF )\n"
+base.atan,"var y = base.atan( 0.0 )\ny = base.atan( -PI/2.0 )\ny = base.atan( PI/2.0 )\ny = base.atan( NaN )\n"
+base.atan2,"var v = base.atan2( 2.0, 2.0 )\nv = base.atan2( 6.0, 2.0 )\nv = base.atan2( -1.0, -1.0 )\nv = base.atan2( 3.0, 0.0 )\nv = base.atan2( -2.0, 0.0 )\nv = base.atan2( 0.0, 0.0 )\nv = base.atan2( 3.0, NaN )\nv = base.atan2( NaN, 2.0 )\n"
+base.atanh,"var y = base.atanh( 0.0 )\ny = base.atanh( 0.9 )\ny = base.atanh( 1.0 )\ny = base.atanh( -1.0 )\ny = base.atanh( NaN )\n"
+base.avercos,"var y = base.avercos( -1.5 )\ny = base.avercos( -0.0 )\n"
+base.aversin,"var y = base.aversin( 1.5 )\ny = base.aversin( 0.0 )\n"
+base.bernoulli,"var y = base.bernoulli( 0 )\ny = base.bernoulli( 1 )\ny = base.bernoulli( 2 )\ny = base.bernoulli( 3 )\ny = base.bernoulli( 4 )\ny = base.bernoulli( 5 )\ny = base.bernoulli( 20 )\ny = base.bernoulli( 260 )\ny = base.bernoulli( 262 )\ny = base.bernoulli( NaN )\n"
+base.besselj0,"var y = base.besselj0( 0.0 )\ny = base.besselj0( 1.0 )\ny = base.besselj0( PINF )\ny = base.besselj0( NINF )\ny = base.besselj0( NaN )\n"
+base.besselj1,"var y = base.besselj1( 0.0 )\ny = base.besselj1( 1.0 )\ny = base.besselj1( PINF )\ny = base.besselj1( NINF )\ny = base.besselj1( NaN )\n"
+base.bessely0,"var y = base.bessely0( 0.0 )\ny = base.bessely0( 1.0 )\ny = base.bessely0( -1.0 )\ny = base.bessely0( PINF )\ny = base.bessely0( NINF )\ny = base.bessely0( NaN )\n"
+base.bessely1,"var y = base.bessely1( 0.0 )\ny = base.bessely1( 1.0 )\ny = base.bessely1( -1.0 )\ny = base.bessely1( PINF )\ny = base.bessely1( NINF )\ny = base.bessely1( NaN )\n"
+base.beta,"var v = base.beta( 0.0, 0.5 )\nv = base.beta( 1.0, 1.0 )\nv = base.beta( -1.0, 2.0 )\nv = base.beta( 5.0, 0.2 )\nv = base.beta( 4.0, 1.0 )\nv = base.beta( NaN, 2.0 )\n"
+base.betainc,"var y = base.betainc( 0.5, 2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, 2.0, false )\ny = base.betainc( 0.2, 1.0, 2.0 )\ny = base.betainc( 0.2, 1.0, 2.0, true, true )\ny = base.betainc( NaN, 1.0, 1.0 )\ny = base.betainc( 0.8, NaN, 1.0 )\ny = base.betainc( 0.8, 1.0, NaN )\ny = base.betainc( 1.5, 1.0, 1.0 )\ny = base.betainc( -0.5, 1.0, 1.0 )\ny = base.betainc( 0.5, -2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, -2.0 )\n"
+base.betaincinv,"var y = base.betaincinv( 0.2, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0, true )\ny = base.betaincinv( 0.4, 1.0, 6.0 )\ny = base.betaincinv( 0.8, 1.0, 6.0 )\ny = base.betaincinv( NaN, 1.0, 1.0 )\ny = base.betaincinv( 0.5, NaN, 1.0 )\ny = base.betaincinv( 0.5, 1.0, NaN )\ny = base.betaincinv( 1.2, 1.0, 1.0 )\ny = base.betaincinv( -0.5, 1.0, 1.0 )\ny = base.betaincinv( 0.5, -2.0, 2.0 )\ny = base.betaincinv( 0.5, 0.0, 2.0 )\ny = base.betaincinv( 0.5, 2.0, -2.0 )\ny = base.betaincinv( 0.5, 2.0, 0.0 )\n"
+base.betaln,"var v = base.betaln( 0.0, 0.0 )\nv = base.betaln( 1.0, 1.0 )\nv = base.betaln( -1.0, 2.0 )\nv = base.betaln( 5.0, 0.2 )\nv = base.betaln( 4.0, 1.0 )\nv = base.betaln( NaN, 2.0 )\n"
+base.binet,"var y = base.binet( 0.0 )\ny = base.binet( 1.0 )\ny = base.binet( 2.0 )\ny = base.binet( 3.0 )\ny = base.binet( 4.0 )\ny = base.binet( 5.0 )\ny = base.binet( NaN )\n"
+base.binomcoef,"var v = base.binomcoef( 8, 2 )\nv = base.binomcoef( 0, 0 )\nv = base.binomcoef( -4, 2 )\nv = base.binomcoef( 5, 3 )\nv = base.binomcoef( NaN, 3 )\nv = base.binomcoef( 5, NaN )\nv = base.binomcoef( NaN, NaN )\n"
+base.binomcoefln,"var v = base.binomcoefln( 8, 2 )\nv = base.binomcoefln( 0, 0 )\nv = base.binomcoefln( -4, 2 )\nv = base.binomcoefln( 88, 3 )\nv = base.binomcoefln( NaN, 3 )\nv = base.binomcoefln( 5, NaN )\nv = base.binomcoefln( NaN, NaN )\n"
+base.boxcox,"var v = base.boxcox( 1.0, 2.5 )\nv = base.boxcox( 4.0, 2.5 )\nv = base.boxcox( 10.0, 2.5 )\nv = base.boxcox( 2.0, 0.0 )\nv = base.boxcox( -1.0, 2.5 )\nv = base.boxcox( 0.0, -1.0 )\n"
+base.boxcox1p,"var v = base.boxcox1p( 1.0, 2.5 )\nv = base.boxcox1p( 4.0, 2.5 )\nv = base.boxcox1p( 10.0, 2.5 )\nv = base.boxcox1p( 2.0, 0.0 )\nv = base.boxcox1p( -1.0, 2.5 )\nv = base.boxcox1p( 0.0, -1.0 )\nv = base.boxcox1p( -1.0, -1.0 )\n"
+base.boxcox1pinv,"var v = base.boxcox1pinv( 1.0, 2.5 )\nv = base.boxcox1pinv( 4.0, 2.5 )\nv = base.boxcox1pinv( 10.0, 2.5 )\nv = base.boxcox1pinv( 2.0, 0.0 )\nv = base.boxcox1pinv( -1.0, 2.5 )\nv = base.boxcox1pinv( 0.0, -1.0 )\nv = base.boxcox1pinv( 1.0, NaN )\nv = base.boxcox1pinv( NaN, 3.1 )\n"
+base.boxcoxinv,"var v = base.boxcoxinv( 1.0, 2.5 )\nv = base.boxcoxinv( 4.0, 2.5 )\nv = base.boxcoxinv( 10.0, 2.5 )\nv = base.boxcoxinv( 2.0, 0.0 )\nv = base.boxcoxinv( -1.0, 2.5 )\nv = base.boxcoxinv( 0.0, -1.0 )\nv = base.boxcoxinv( 1.0, NaN )\nv = base.boxcoxinv( NaN, 3.1 )\n"
+base.cabs,"var y = base.cabs( 5.0, 3.0 )\n"
+base.cabs2,"var y = base.cabs2( 5.0, 3.0 )\n"
+base.cadd,"var y = base.cadd( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nvar out = new Float32Array( 2 );\ny = base.cadd( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( y === out )\n"
+base.cbrt,"var y = base.cbrt( 64.0 )\ny = base.cbrt( 27.0 )\ny = base.cbrt( 0.0 )\ny = base.cbrt( -0.0 )\ny = base.cbrt( -9.0 )\ny = base.cbrt( NaN )\n"
+base.cceil,"var out = base.cceil( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cceil( out, 5.5, 3.3 )\nvar bool = ( v === out )\n"
+base.cceiln,"var out = base.cceiln( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cceiln( out, 5.555, -3.333, -2 )\nvar bool = ( v === out )\n"
+base.ccis,"var y = base.ccis( 0.0, 0.0 )\nvar y = base.ccis( 1.0, 0.0 )\nvar out = new Float64Array( 2 );\nvar v = base.ccis( out, 1.0, 0.0 )\nvar bool = ( v === out )\n"
+base.cdiv,"var y = base.cdiv( -13.0, -1.0, -2.0, 1.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cdiv( out, -13.0, -1.0, -2.0, 1.0 )\nvar bool = ( v === out )\n"
+base.ceil,"var y = base.ceil( 3.14 )\ny = base.ceil( -4.2 )\ny = base.ceil( -4.6 )\ny = base.ceil( 9.5 )\ny = base.ceil( -0.0 )\n"
+base.ceil2,"var y = base.ceil2( 3.14 )\ny = base.ceil2( -4.2 )\ny = base.ceil2( -4.6 )\ny = base.ceil2( 9.5 )\ny = base.ceil2( 13.0 )\ny = base.ceil2( -13.0 )\ny = base.ceil2( -0.0 )\n"
+base.ceil10,"var y = base.ceil10( 3.14 )\ny = base.ceil10( -4.2 )\ny = base.ceil10( -4.6 )\ny = base.ceil10( 9.5 )\ny = base.ceil10( 13.0 )\ny = base.ceil10( -13.0 )\ny = base.ceil10( -0.0 )\n"
+base.ceilb,"\n// Round to 4 decimal places:\nvar y = base.ceilb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.ceilb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward positive infinity:\ny = base.ceilb( 5.0, 1, 2 )\n"
+base.ceiln,"\n// Round to 2 decimal places:\nvar y = base.ceiln( 3.14159, -2 )\n\n// If `n = 0`, standard round toward positive infinity behavior:\ny = base.ceiln( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.ceiln( 12368.0, 3 )\n"
+base.ceilsd,"var y = base.ceilsd( 3.14159, 5 )\ny = base.ceilsd( 3.14159, 1 )\ny = base.ceilsd( 12368.0, 2 )\ny = base.ceilsd( 0.0313, 2, 2 )\n"
+base.cexp,"var y = base.cexp( 0.0, 0.0 )\ny = base.cexp( 0.0, 1.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cexp( out, 0.0, 1.0 )\nvar bool = ( v === out )\n"
+base.cflipsign,"var out = base.cflipsign( -4.2, 5.5, -9 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cflipsign( out, -4.2, 5.5, 8 )\nvar bool = ( v === out )\n"
+base.cfloor,"var out = base.cfloor( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cfloor( out, 5.5, 3.3 )\nvar bool = ( v === out )\n"
+base.cfloorn,"var out = base.cfloorn( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cfloorn( out, 5.555, -3.333, -2 )\nvar bool = ( v === out )\n"
+base.cinv,"var y = base.cinv( 2.0, 4.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cinv( out, 2.0, 4.0 )\nvar bool = ( v === out )\n"
+base.clamp,"var y = base.clamp( 3.14, 0.0, 5.0 )\ny = base.clamp( -3.14, 0.0, 5.0 )\ny = base.clamp( 3.14, 0.0, 3.0 )\ny = base.clamp( -0.0, 0.0, 5.0 )\ny = base.clamp( 0.0, -3.14, -0.0 )\ny = base.clamp( NaN, 0.0, 5.0 )\n"
+base.cmul,"var out = base.cmul( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\nvar v = base.cmul( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( v === out )\n"
+base.cneg,"var out = base.cneg( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cneg( out, -4.2, 5.5 )\nvar bool = ( v === out )\n"
+base.continuedFraction,"\n// Continued fraction for (e-1)^(-1):\nfunction closure() {\n var i = 0;\n return function() {\n i += 1;\n return [ i, i ];\n };\n};\nvar gen = closure();\nvar out = base.continuedFraction( gen )\n\n// Using an ES6 generator:\nfunction* generator() {\n var i = 0;\n while ( true ) {\n i += 1;\n yield [ i, i ];\n }\n};\ngen = generator();\nout = base.continuedFraction( gen )\n\n// Set options:\nout = base.continuedFraction( generator(), { 'keep': true } )\nout = base.continuedFraction( generator(), { 'maxIter': 10 } )\nout = base.continuedFraction( generator(), { 'tolerance': 1e-1 } )\n"
+base.copysign,"var z = base.copysign( -3.14, 10.0 )\nz = base.copysign( 3.14, -1.0 )\nz = base.copysign( 1.0, -0.0 )\nz = base.copysign( -3.14, -0.0 )\nz = base.copysign( -0.0, 1.0 )\n"
+base.cos,"var y = base.cos( 0.0 )\ny = base.cos( PI/4.0 )\ny = base.cos( -PI/6.0 )\ny = base.cos( NaN )\n"
+base.cosh,"var y = base.cosh( 0.0 )\ny = base.cosh( 2.0 )\ny = base.cosh( -2.0 )\ny = base.cosh( NaN )\n"
+base.cosm1,"var y = base.cosm1( 0.0 )\ny = base.cosm1( PI/4.0 )\ny = base.cosm1( -PI/6.0 )\ny = base.cosm1( NaN )\n"
+base.cospi,"var y = base.cospi( 0.0 )\ny = base.cospi( 0.5 )\ny = base.cospi( 0.1 )\ny = base.cospi( NaN )\n"
+base.covercos,"var y = base.covercos( 3.14 )\ny = base.covercos( -4.2 )\ny = base.covercos( -4.6 )\ny = base.covercos( 9.5 )\ny = base.covercos( -0.0 )\n"
+base.coversin,"var y = base.coversin( 3.14 )\ny = base.coversin( -4.2 )\ny = base.coversin( -4.6 )\ny = base.coversin( 9.5 )\ny = base.coversin( -0.0 )\n"
+base.cphase,"var phi = base.cphase( 5.0, 3.0 )\n"
+base.cpolar,"var out = base.cpolar( 5.0, 3.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cpolar( out, 5.0, 3.0 )\nvar bool = ( v === out )\n"
+base.cround,"var out = base.cround( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cround( out, 5.5, 3.3 )\nvar bool = ( v === out )\n"
+base.croundn,"var out = base.croundn( 5.555, -3.336, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.croundn( out, 5.555, -3.336, -2 )\nvar bool = ( v === out )\n"
+base.csignum,"var out = base.csignum( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.csignum( out, -4.2, 5.5 )\nvar bool = ( v === out )\n"
+base.csub,"var out = base.csub( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.csub( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( v === out )\n"
+base.dasum,"\n// Standard usage:\nvar x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nvar sum = base.dasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.dasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.dasum( N, x1, stride )\n"
+base.daxpy,"\n// Standard usage:\nvar x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nvar alpha = 5.0;\nbase.daxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\ny = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nbase.daxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.daxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n"
+base.dcopy,"\n// Standard usage:\nvar x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.dcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar N = base.floor( x.length / 2 );\nbase.dcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.dcopy( N, x1, -2, y1, 1 )\ny0\n"
+base.deg2rad,"var r = base.deg2rad( 90.0 )\nr = base.deg2rad( -45.0 )\nr = base.deg2rad( NaN )\n"
+base.digamma,"var y = base.digamma( -2.5 )\ny = base.digamma( 1.0 )\ny = base.digamma( 10.0 )\ny = base.digamma( NaN )\ny = base.digamma( -1.0 )\n"
+base.diracDelta,"var y = base.diracDelta( 3.14 )\ny = base.diracDelta( 0.0 )\n"
+base.dists.arcsine.Arcsine,"var arcsine = base.dists.arcsine.Arcsine( 0.0, 1.0 );\narcsine.a\narcsine.b\narcsine.entropy\narcsine.kurtosis\narcsine.mean\narcsine.median\narcsine.mode\narcsine.skewness\narcsine.stdev\narcsine.variance\narcsine.cdf( 0.8 )\narcsine.logcdf( 0.8 )\narcsine.logpdf( 0.4 )\narcsine.pdf( 0.8 )\narcsine.quantile( 0.8 )\n"
+base.dists.arcsine.cdf,"var y = base.dists.arcsine.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.cdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.cdf( 2.0, 1.0, 0.0 )\n"
+base.dists.arcsine.entropy,"var v = base.dists.arcsine.entropy( 0.0, 1.0 )\nv = base.dists.arcsine.entropy( 4.0, 12.0 )\nv = base.dists.arcsine.entropy( 2.0, 8.0 )\n"
+base.dists.arcsine.kurtosis,"var v = base.dists.arcsine.kurtosis( 0.0, 1.0 )\nv = base.dists.arcsine.kurtosis( 4.0, 12.0 )\nv = base.dists.arcsine.kurtosis( 2.0, 8.0 )\n"
+base.dists.arcsine.logcdf,"var y = base.dists.arcsine.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logcdf( 2.0, 1.0, 0.0 )\n"
+base.dists.arcsine.logpdf,"var y = base.dists.arcsine.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logpdf( 2.0, 3.0, 1.0 )\n"
+base.dists.arcsine.mean,"var v = base.dists.arcsine.mean( 0.0, 1.0 )\nv = base.dists.arcsine.mean( 4.0, 12.0 )\nv = base.dists.arcsine.mean( 2.0, 8.0 )\n"
+base.dists.arcsine.median,"var v = base.dists.arcsine.median( 0.0, 1.0 )\nv = base.dists.arcsine.median( 4.0, 12.0 )\nv = base.dists.arcsine.median( 2.0, 8.0 )\n"
+base.dists.arcsine.mode,"var v = base.dists.arcsine.mode( 0.0, 1.0 )\nv = base.dists.arcsine.mode( 4.0, 12.0 )\nv = base.dists.arcsine.mode( 2.0, 8.0 )\n"
+base.dists.arcsine.pdf,"var y = base.dists.arcsine.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.pdf( 2.0, 3.0, 1.0 )\n"
+base.dists.arcsine.quantile,"var y = base.dists.arcsine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.arcsine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, 0.0, NaN )\ny = base.dists.arcsine.quantile( 0.5, 2.0, 1.0 )\n"
+base.dists.arcsine.skewness,"var v = base.dists.arcsine.skewness( 0.0, 1.0 )\nv = base.dists.arcsine.skewness( 4.0, 12.0 )\nv = base.dists.arcsine.skewness( 2.0, 8.0 )\n"
+base.dists.arcsine.stdev,"var v = base.dists.arcsine.stdev( 0.0, 1.0 )\nv = base.dists.arcsine.stdev( 4.0, 12.0 )\nv = base.dists.arcsine.stdev( 2.0, 8.0 )\n"
+base.dists.arcsine.variance,"var v = base.dists.arcsine.variance( 0.0, 1.0 )\nv = base.dists.arcsine.variance( 4.0, 12.0 )\nv = base.dists.arcsine.variance( 2.0, 8.0 )\n"
+base.dists.bernoulli.Bernoulli,"var bernoulli = base.dists.bernoulli.Bernoulli( 0.6 );\nbernoulli.p\nbernoulli.entropy\nbernoulli.kurtosis\nbernoulli.mean\nbernoulli.median\nbernoulli.skewness\nbernoulli.stdev\nbernoulli.variance\nbernoulli.cdf( 0.5 )\nbernoulli.mgf( 3.0 )\nbernoulli.pmf( 0.0 )\nbernoulli.quantile( 0.7 )\n"
+base.dists.bernoulli.cdf,"var y = base.dists.bernoulli.cdf( 0.5, 0.5 )\ny = base.dists.bernoulli.cdf( 0.8, 0.1 )\ny = base.dists.bernoulli.cdf( -1.0, 0.4 )\ny = base.dists.bernoulli.cdf( 1.5, 0.4 )\ny = base.dists.bernoulli.cdf( NaN, 0.5 )\ny = base.dists.bernoulli.cdf( 0.0, NaN )\n\n// Invalid probability:\ny = base.dists.bernoulli.cdf( 2.0, 1.4 )\n"
+base.dists.bernoulli.entropy,"var v = base.dists.bernoulli.entropy( 0.1 )\nv = base.dists.bernoulli.entropy( 0.5 )\n"
+base.dists.bernoulli.kurtosis,"var v = base.dists.bernoulli.kurtosis( 0.1 )\nv = base.dists.bernoulli.kurtosis( 0.5 )\n"
+base.dists.bernoulli.mean,"var v = base.dists.bernoulli.mean( 0.1 )\nv = base.dists.bernoulli.mean( 0.5 )\n"
+base.dists.bernoulli.median,"var v = base.dists.bernoulli.median( 0.1 )\nv = base.dists.bernoulli.median( 0.8 )\n"
+base.dists.bernoulli.mgf,"var y = base.dists.bernoulli.mgf( 0.2, 0.5 )\ny = base.dists.bernoulli.mgf( 0.4, 0.5 )\ny = base.dists.bernoulli.mgf( NaN, 0.0 )\ny = base.dists.bernoulli.mgf( 0.0, NaN )\ny = base.dists.bernoulli.mgf( -2.0, -1.0 )\ny = base.dists.bernoulli.mgf( 0.2, 2.0 )\n"
+base.dists.bernoulli.mode,"var v = base.dists.bernoulli.mode( 0.1 )\nv = base.dists.bernoulli.mode( 0.8 )\n"
+base.dists.bernoulli.pmf,"var y = base.dists.bernoulli.pmf( 1.0, 0.3 )\ny = base.dists.bernoulli.pmf( 0.0, 0.7 )\ny = base.dists.bernoulli.pmf( -1.0, 0.5 )\ny = base.dists.bernoulli.pmf( 0.0, NaN )\ny = base.dists.bernoulli.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.bernoulli.pmf( 0.0, 1.5 )\n"
+base.dists.bernoulli.quantile,"var y = base.dists.bernoulli.quantile( 0.8, 0.4 )\ny = base.dists.bernoulli.quantile( 0.5, 0.4 )\ny = base.dists.bernoulli.quantile( 0.9, 0.1 )\ny = base.dists.bernoulli.quantile( -0.2, 0.1 )\ny = base.dists.bernoulli.quantile( NaN, 0.8 )\ny = base.dists.bernoulli.quantile( 0.4, NaN )\ny = base.dists.bernoulli.quantile( 0.5, -1.0 )\ny = base.dists.bernoulli.quantile( 0.5, 1.5 )\n"
+base.dists.bernoulli.skewness,"var v = base.dists.bernoulli.skewness( 0.1 )\nv = base.dists.bernoulli.skewness( 0.5 )\n"
+base.dists.bernoulli.stdev,"var v = base.dists.bernoulli.stdev( 0.1 )\nv = base.dists.bernoulli.stdev( 0.5 )\n"
+base.dists.bernoulli.variance,"var v = base.dists.bernoulli.variance( 0.1 )\nv = base.dists.bernoulli.variance( 0.5 )\n"
+base.dists.beta.Beta,"var beta = base.dists.beta.Beta( 1.0, 1.0 );\nbeta.alpha\nbeta.beta\nbeta.entropy\nbeta.kurtosis\nbeta.mean\nbeta.median\nbeta.mode\nbeta.skewness\nbeta.stdev\nbeta.variance\nbeta.cdf( 0.8 )\nbeta.logcdf( 0.8 )\nbeta.logpdf( 1.0 )\nbeta.mgf( 3.14 )\nbeta.pdf( 1.0 )\nbeta.quantile( 0.8 )\n"
+base.dists.beta.cdf,"var y = base.dists.beta.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.cdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.cdf( 0.0, 1.0, NaN )\n"
+base.dists.beta.entropy,"var v = base.dists.beta.entropy( 1.0, 1.0 )\nv = base.dists.beta.entropy( 4.0, 12.0 )\nv = base.dists.beta.entropy( 8.0, 2.0 )\nv = base.dists.beta.entropy( 1.0, -0.1 )\nv = base.dists.beta.entropy( -0.1, 1.0 )\nv = base.dists.beta.entropy( 2.0, NaN )\nv = base.dists.beta.entropy( NaN, 2.0 )\n"
+base.dists.beta.kurtosis,"var v = base.dists.beta.kurtosis( 1.0, 1.0 )\nv = base.dists.beta.kurtosis( 4.0, 12.0 )\nv = base.dists.beta.kurtosis( 8.0, 2.0 )\nv = base.dists.beta.kurtosis( 1.0, -0.1 )\nv = base.dists.beta.kurtosis( -0.1, 1.0 )\nv = base.dists.beta.kurtosis( 2.0, NaN )\nv = base.dists.beta.kurtosis( NaN, 2.0 )\n"
+base.dists.beta.logcdf,"var y = base.dists.beta.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.logcdf( 0.0, 1.0, NaN )\n"
+base.dists.beta.logpdf,"var y = base.dists.beta.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 1.0, NaN )\n"
+base.dists.beta.mean,"var v = base.dists.beta.mean( 1.0, 1.0 )\nv = base.dists.beta.mean( 4.0, 12.0 )\nv = base.dists.beta.mean( 8.0, 2.0 )\n"
+base.dists.beta.median,"var v = base.dists.beta.median( 1.0, 1.0 )\nv = base.dists.beta.median( 4.0, 12.0 )\nv = base.dists.beta.median( 8.0, 2.0 )\nv = base.dists.beta.median( 1.0, -0.1 )\nv = base.dists.beta.median( -0.1, 1.0 )\nv = base.dists.beta.median( 2.0, NaN )\nv = base.dists.beta.median( NaN, 2.0 )\n"
+base.dists.beta.mgf,"var y = base.dists.beta.mgf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.mgf( 3.0, 2.0, 2.0 )\ny = base.dists.beta.mgf( -0.8, 4.0, 4.0 )\ny = base.dists.beta.mgf( NaN, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.0, NaN, 1.0 )\ny = base.dists.beta.mgf( 0.0, 1.0, NaN )\ny = base.dists.beta.mgf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.mgf( 2.0, 0.5, 0.0 )\n"
+base.dists.beta.mode,"var v = base.dists.beta.mode( 4.0, 12.0 )\nv = base.dists.beta.mode( 8.0, 2.0 )\nv = base.dists.beta.mode( 1.0, 1.0 )\n"
+base.dists.beta.pdf,"var y = base.dists.beta.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.pdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.pdf( 0.5, 1.0, NaN )\n"
+base.dists.beta.quantile,"var y = base.dists.beta.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.beta.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.beta.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.beta.quantile( NaN, 1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, NaN, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, NaN )\ny = base.dists.beta.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.beta.skewness,"var v = base.dists.beta.skewness( 1.0, 1.0 )\nv = base.dists.beta.skewness( 4.0, 12.0 )\nv = base.dists.beta.skewness( 8.0, 2.0 )\nv = base.dists.beta.skewness( 1.0, -0.1 )\nv = base.dists.beta.skewness( -0.1, 1.0 )\nv = base.dists.beta.skewness( 2.0, NaN )\nv = base.dists.beta.skewness( NaN, 2.0 )\n"
+base.dists.beta.stdev,"var v = base.dists.beta.stdev( 1.0, 1.0 )\nv = base.dists.beta.stdev( 4.0, 12.0 )\nv = base.dists.beta.stdev( 8.0, 2.0 )\nv = base.dists.beta.stdev( 1.0, -0.1 )\nv = base.dists.beta.stdev( -0.1, 1.0 )\nv = base.dists.beta.stdev( 2.0, NaN )\nv = base.dists.beta.stdev( NaN, 2.0 )\n"
+base.dists.beta.variance,"var v = base.dists.beta.variance( 1.0, 1.0 )\nv = base.dists.beta.variance( 4.0, 12.0 )\nv = base.dists.beta.variance( 8.0, 2.0 )\nv = base.dists.beta.variance( 1.0, -0.1 )\nv = base.dists.beta.variance( -0.1, 1.0 )\nv = base.dists.beta.variance( 2.0, NaN )\nv = base.dists.beta.variance( NaN, 2.0 )\n"
+base.dists.betaprime.BetaPrime,"var betaprime = base.dists.betaprime.BetaPrime( 6.0, 5.0 );\nbetaprime.alpha\nbetaprime.beta\nbetaprime.kurtosis\nbetaprime.mean\nbetaprime.mode\nbetaprime.skewness\nbetaprime.stdev\nbetaprime.variance\nbetaprime.cdf( 0.8 )\nbetaprime.logcdf( 0.8 )\nbetaprime.logpdf( 1.0 )\nbetaprime.pdf( 1.0 )\nbetaprime.quantile( 0.8 )\n"
+base.dists.betaprime.cdf,"var y = base.dists.betaprime.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.cdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, 1.0, NaN )\n"
+base.dists.betaprime.kurtosis,"var v = base.dists.betaprime.kurtosis( 2.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 4.0, 12.0 )\nv = base.dists.betaprime.kurtosis( 8.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 1.0, 2.8 )\nv = base.dists.betaprime.kurtosis( 1.0, -0.1 )\nv = base.dists.betaprime.kurtosis( -0.1, 5.0 )\nv = base.dists.betaprime.kurtosis( 2.0, NaN )\nv = base.dists.betaprime.kurtosis( NaN, 6.0 )\n"
+base.dists.betaprime.logcdf,"var y = base.dists.betaprime.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, 1.0, NaN )\n"
+base.dists.betaprime.logpdf,"var y = base.dists.betaprime.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 1.0, NaN )\n"
+base.dists.betaprime.mean,"var v = base.dists.betaprime.mean( 1.0, 2.0 )\nv = base.dists.betaprime.mean( 4.0, 12.0 )\nv = base.dists.betaprime.mean( 8.0, 2.0 )\n"
+base.dists.betaprime.mode,"var v = base.dists.betaprime.mode( 1.0, 2.0 )\nv = base.dists.betaprime.mode( 4.0, 12.0 )\nv = base.dists.betaprime.mode( 8.0, 2.0 )\n"
+base.dists.betaprime.pdf,"var y = base.dists.betaprime.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.pdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 1.0, NaN )\n"
+base.dists.betaprime.quantile,"var y = base.dists.betaprime.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.betaprime.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, NaN )\ny = base.dists.betaprime.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.betaprime.skewness,"var v = base.dists.betaprime.skewness( 2.0, 4.0 )\nv = base.dists.betaprime.skewness( 4.0, 12.0 )\nv = base.dists.betaprime.skewness( 8.0, 4.0 )\nv = base.dists.betaprime.skewness( 1.0, 2.8 )\nv = base.dists.betaprime.skewness( 1.0, -0.1 )\nv = base.dists.betaprime.skewness( -0.1, 4.0 )\nv = base.dists.betaprime.skewness( 2.0, NaN )\nv = base.dists.betaprime.skewness( NaN, 4.0 )\n"
+base.dists.betaprime.stdev,"var v = base.dists.betaprime.stdev( 1.0, 2.5 )\nv = base.dists.betaprime.stdev( 4.0, 12.0 )\nv = base.dists.betaprime.stdev( 8.0, 2.5 )\nv = base.dists.betaprime.stdev( 8.0, 1.0 )\nv = base.dists.betaprime.stdev( 1.0, -0.1 )\nv = base.dists.betaprime.stdev( -0.1, 3.0 )\nv = base.dists.betaprime.stdev( 2.0, NaN )\nv = base.dists.betaprime.stdev( NaN, 3.0 )\n"
+base.dists.betaprime.variance,"var v = base.dists.betaprime.variance( 1.0, 2.5 )\nv = base.dists.betaprime.variance( 4.0, 12.0 )\nv = base.dists.betaprime.variance( 8.0, 2.5 )\nv = base.dists.betaprime.variance( 8.0, 1.0 )\nv = base.dists.betaprime.variance( 1.0, -0.1 )\nv = base.dists.betaprime.variance( -0.1, 3.0 )\nv = base.dists.betaprime.variance( 2.0, NaN )\nv = base.dists.betaprime.variance( NaN, 3.0 )\n"
+base.dists.binomial.Binomial,"var binomial = base.dists.binomial.Binomial( 8, 0.5 );\nbinomial.n\nbinomial.p\nbinomial.kurtosis\nbinomial.mean\nbinomial.median\nbinomial.mode\nbinomial.skewness\nbinomial.stdev\nbinomial.variance\nbinomial.cdf( 2.9 )\nbinomial.logpmf( 3.0 )\nbinomial.mgf( 0.2 )\nbinomial.pmf( 3.0 )\nbinomial.quantile( 0.8 )\n"
+base.dists.binomial.cdf,"var y = base.dists.binomial.cdf( 3.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 21.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 5.0, 10, 0.4 )\ny = base.dists.binomial.cdf( 0.0, 10, 0.4 )\ny = base.dists.binomial.cdf( NaN, 20, 0.5 )\ny = base.dists.binomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.cdf( 0.0, 20, NaN )\ny = base.dists.binomial.cdf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.binomial.cdf( 2.0, 20, 1.5 )\n"
+base.dists.binomial.entropy,"var v = base.dists.binomial.entropy( 100, 0.1 )\nv = base.dists.binomial.entropy( 20, 0.5 )\nv = base.dists.binomial.entropy( 10.3, 0.5 )\nv = base.dists.binomial.entropy( 20, 1.1 )\nv = base.dists.binomial.entropy( 20, NaN )\n"
+base.dists.binomial.kurtosis,"var v = base.dists.binomial.kurtosis( 100, 0.1 )\nv = base.dists.binomial.kurtosis( 20, 0.5 )\nv = base.dists.binomial.kurtosis( 10.3, 0.5 )\nv = base.dists.binomial.kurtosis( 20, 1.1 )\nv = base.dists.binomial.kurtosis( 20, NaN )\n"
+base.dists.binomial.logpmf,"var y = base.dists.binomial.logpmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( NaN, 20, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, 20, NaN )\ny = base.dists.binomial.logpmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.logpmf( 2.0, 20, 1.5 )\n"
+base.dists.binomial.mean,"var v = base.dists.binomial.mean( 100, 0.1 )\nv = base.dists.binomial.mean( 20, 0.5 )\nv = base.dists.binomial.mean( 10.3, 0.5 )\nv = base.dists.binomial.mean( 20, 1.1 )\nv = base.dists.binomial.mean( 20, NaN )\n"
+base.dists.binomial.median,"var v = base.dists.binomial.median( 100, 0.1 )\nv = base.dists.binomial.median( 20, 0.5 )\nv = base.dists.binomial.median( 10.3, 0.5 )\nv = base.dists.binomial.median( 20, 1.1 )\nv = base.dists.binomial.median( 20, NaN )\n"
+base.dists.binomial.mgf,"var y = base.dists.binomial.mgf( 0.5, 20, 0.2 )\ny = base.dists.binomial.mgf( 5.0, 20, 0.2 )\ny = base.dists.binomial.mgf( 0.9, 10, 0.4 )\ny = base.dists.binomial.mgf( 0.0, 10, 0.4 )\ny = base.dists.binomial.mgf( NaN, 20, 0.5 )\ny = base.dists.binomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.mgf( 0.0, 20, NaN )\ny = base.dists.binomial.mgf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.mgf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.mgf( 2.0, 20, -1.0 )\ny = base.dists.binomial.mgf( 2.0, 20, 1.5 )\n"
+base.dists.binomial.mode,"var v = base.dists.binomial.mode( 100, 0.1 )\nv = base.dists.binomial.mode( 20, 0.5 )\nv = base.dists.binomial.mode( 10.3, 0.5 )\nv = base.dists.binomial.mode( 20, 1.1 )\nv = base.dists.binomial.mode( 20, NaN )\n"
+base.dists.binomial.pmf,"var y = base.dists.binomial.pmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.pmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.pmf( NaN, 20, 0.5 )\ny = base.dists.binomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.pmf( 0.0, 20, NaN )\ny = base.dists.binomial.pmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.pmf( 2.0, 20, 1.5 )\n"
+base.dists.binomial.quantile,"var y = base.dists.binomial.quantile( 0.4, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.8, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.5, 10, 0.4 )\ny = base.dists.binomial.quantile( 0.0, 10, 0.4 )\ny = base.dists.binomial.quantile( 1.0, 10, 0.4 )\ny = base.dists.binomial.quantile( NaN, 20, 0.5 )\ny = base.dists.binomial.quantile( 0.2, NaN, 0.5 )\ny = base.dists.binomial.quantile( 0.2, 20, NaN )\ny = base.dists.binomial.quantile( 0.5, 1.5, 0.5 )\ny = base.dists.binomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.binomial.quantile( 0.5, 20, -1.0 )\ny = base.dists.binomial.quantile( 0.5, 20, 1.5 )\n"
+base.dists.binomial.skewness,"var v = base.dists.binomial.skewness( 100, 0.1 )\nv = base.dists.binomial.skewness( 20, 0.5 )\nv = base.dists.binomial.skewness( 10.3, 0.5 )\nv = base.dists.binomial.skewness( 20, 1.1 )\nv = base.dists.binomial.skewness( 20, NaN )\n"
+base.dists.binomial.stdev,"var v = base.dists.binomial.stdev( 100, 0.1 )\nv = base.dists.binomial.stdev( 20, 0.5 )\nv = base.dists.binomial.stdev( 10.3, 0.5 )\nv = base.dists.binomial.stdev( 20, 1.1 )\nv = base.dists.binomial.stdev( 20, NaN )\n"
+base.dists.binomial.variance,"var v = base.dists.binomial.variance( 100, 0.1 )\nv = base.dists.binomial.variance( 20, 0.5 )\nv = base.dists.binomial.variance( 10.3, 0.5 )\nv = base.dists.binomial.variance( 20, 1.1 )\nv = base.dists.binomial.variance( 20, NaN )\n"
+base.dists.cauchy.Cauchy,"var cauchy = base.dists.cauchy.Cauchy( 0.0, 1.0 );\ncauchy.x0\ncauchy.gamma\ncauchy.entropy\ncauchy.median\ncauchy.mode\ncauchy.cdf( 0.8 )\ncauchy.logcdf( 1.0 )\ncauchy.logpdf( 1.0 )\ncauchy.pdf( 1.0 )\ncauchy.quantile( 0.8 )\n"
+base.dists.cauchy.cdf,"var y = base.dists.cauchy.cdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.cdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.cdf( 1.0, NaN, 3.0 )\n"
+base.dists.cauchy.entropy,"var v = base.dists.cauchy.entropy( 10.0, 7.0 )\nv = base.dists.cauchy.entropy( 22.0, 0.5 )\nv = base.dists.cauchy.entropy( 10.3, -0.5 )\n"
+base.dists.cauchy.logcdf,"var y = base.dists.cauchy.logcdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.logcdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.logcdf( 1.0, NaN, 3.0 )\n"
+base.dists.cauchy.logpdf,"var y = base.dists.cauchy.logpdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.logpdf( 2.0, 1.0, -2.0 )\n"
+base.dists.cauchy.median,"var v = base.dists.cauchy.median( 10.0, 5.0 )\nv = base.dists.cauchy.median( 7.0, 0.5 )\nv = base.dists.cauchy.median( 10.3, -0.5 )\n"
+base.dists.cauchy.mode,"var v = base.dists.cauchy.mode( 10.0, 5.0 )\nv = base.dists.cauchy.mode( 7.0, 0.5 )\nv = base.dists.cauchy.mode( 10.3, -0.5 )\n"
+base.dists.cauchy.pdf,"var y = base.dists.cauchy.pdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.pdf( 2.0, 1.0, -2.0 )\n"
+base.dists.cauchy.quantile,"var y = base.dists.cauchy.quantile( 0.3, 2.0, 2.0 )\ny = base.dists.cauchy.quantile( 0.8, 10, 2.0 )\ny = base.dists.cauchy.quantile( 0.1, 10.0, 2.0 )\ny = base.dists.cauchy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.chi.cdf,"var y = base.dists.chi.cdf( 2.0, 3.0 )\ny = base.dists.chi.cdf( 1.0, 0.5 )\ny = base.dists.chi.cdf( -1.0, 4.0 )\ny = base.dists.chi.cdf( NaN, 1.0 )\ny = base.dists.chi.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.cdf( 2.0, 0.0 )\ny = base.dists.chi.cdf( -2.0, 0.0 )\ny = base.dists.chi.cdf( 0.0, 0.0 )\n"
+base.dists.chi.Chi,"var chi = base.dists.chi.Chi( 6.0 );\nchi.k\nchi.entropy\nchi.kurtosis\nchi.mean\nchi.mode\nchi.skewness\nchi.stdev\nchi.variance\nchi.cdf( 1.0 )\nchi.logpdf( 1.5 )\nchi.pdf( 1.5 )\nchi.quantile( 0.5 )\n"
+base.dists.chi.entropy,"var v = base.dists.chi.entropy( 11.0 )\nv = base.dists.chi.entropy( 1.5 )\n"
+base.dists.chi.kurtosis,"var v = base.dists.chi.kurtosis( 9.0 )\nv = base.dists.chi.kurtosis( 1.5 )\n"
+base.dists.chi.logpdf,"var y = base.dists.chi.logpdf( 0.3, 4.0 )\ny = base.dists.chi.logpdf( 0.7, 0.7 )\ny = base.dists.chi.logpdf( -1.0, 0.5 )\ny = base.dists.chi.logpdf( 0.0, NaN )\ny = base.dists.chi.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.logpdf( 0.0, 0.0, 2.0 )\n"
+base.dists.chi.mean,"var v = base.dists.chi.mean( 11.0 )\nv = base.dists.chi.mean( 4.5 )\n"
+base.dists.chi.mode,"var v = base.dists.chi.mode( 11.0 )\nv = base.dists.chi.mode( 1.5 )\n"
+base.dists.chi.pdf,"var y = base.dists.chi.pdf( 0.3, 4.0 )\ny = base.dists.chi.pdf( 0.7, 0.7 )\ny = base.dists.chi.pdf( -1.0, 0.5 )\ny = base.dists.chi.pdf( 0.0, NaN )\ny = base.dists.chi.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.pdf( 0.0, 0.0, 2.0 )\n"
+base.dists.chi.quantile,"var y = base.dists.chi.quantile( 0.8, 1.0 )\ny = base.dists.chi.quantile( 0.5, 4.0 )\ny = base.dists.chi.quantile( 0.8, 0.1 )\ny = base.dists.chi.quantile( -0.2, 0.5 )\ny = base.dists.chi.quantile( 1.1, 0.5 )\ny = base.dists.chi.quantile( NaN, 1.0 )\ny = base.dists.chi.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.quantile( 0.3, 0.0 )\ny = base.dists.chi.quantile( 0.9, 0.0 )\n"
+base.dists.chi.skewness,"var v = base.dists.chi.skewness( 11.0 )\nv = base.dists.chi.skewness( 1.5 )\n"
+base.dists.chi.stdev,"var v = base.dists.chi.stdev( 11.0 )\nv = base.dists.chi.stdev( 1.5 )\n"
+base.dists.chi.variance,"var v = base.dists.chi.variance( 11.0 )\nv = base.dists.chi.variance( 1.5 )\n"
+base.dists.chisquare.cdf,"var y = base.dists.chisquare.cdf( 2.0, 3.0 )\ny = base.dists.chisquare.cdf( 1.0, 0.5 )\ny = base.dists.chisquare.cdf( -1.0, 4.0 )\ny = base.dists.chisquare.cdf( NaN, 1.0 )\ny = base.dists.chisquare.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.cdf( 2.0, 0.0 )\ny = base.dists.chisquare.cdf( -2.0, 0.0 )\ny = base.dists.chisquare.cdf( 0.0, 0.0 )\n"
+base.dists.chisquare.ChiSquare,"var chisquare = base.dists.chisquare.ChiSquare( 6.0 );\nchisquare.k\nchisquare.entropy\nchisquare.kurtosis\nchisquare.mean\nchisquare.mode\nchisquare.skewness\nchisquare.stdev\nchisquare.variance\nchisquare.cdf( 3.0 )\nchisquare.mgf( 0.2 )\nchisquare.pdf( 1.5 )\nchisquare.quantile( 0.5 )\n"
+base.dists.chisquare.entropy,"var v = base.dists.chisquare.entropy( 11.0 )\nv = base.dists.chisquare.entropy( 1.5 )\n"
+base.dists.chisquare.kurtosis,"var v = base.dists.chisquare.kurtosis( 9.0 )\nv = base.dists.chisquare.kurtosis( 1.5 )\n"
+base.dists.chisquare.logpdf,"var y = base.dists.chisquare.logpdf( 0.3, 4.0 )\ny = base.dists.chisquare.logpdf( 0.7, 0.7 )\ny = base.dists.chisquare.logpdf( -1.0, 0.5 )\ny = base.dists.chisquare.logpdf( 0.0, NaN )\ny = base.dists.chisquare.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.logpdf( 0.0, 0.0, 2.0 )\n"
+base.dists.chisquare.mean,"var v = base.dists.chisquare.mean( 11.0 )\nv = base.dists.chisquare.mean( 4.5 )\n"
+base.dists.chisquare.mode,"var v = base.dists.chisquare.mode( 11.0 )\nv = base.dists.chisquare.mode( 1.5 )\n"
+base.dists.chisquare.pdf,"var y = base.dists.chisquare.pdf( 0.3, 4.0 )\ny = base.dists.chisquare.pdf( 0.7, 0.7 )\ny = base.dists.chisquare.pdf( -1.0, 0.5 )\ny = base.dists.chisquare.pdf( 0.0, NaN )\ny = base.dists.chisquare.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.pdf( 0.0, 0.0, 2.0 )\n"
+base.dists.chisquare.quantile,"var y = base.dists.chisquare.quantile( 0.8, 1.0 )\ny = base.dists.chisquare.quantile( 0.5, 4.0 )\ny = base.dists.chisquare.quantile( 0.8, 0.1 )\ny = base.dists.chisquare.quantile( -0.2, 0.5 )\ny = base.dists.chisquare.quantile( 1.1, 0.5 )\ny = base.dists.chisquare.quantile( NaN, 1.0 )\ny = base.dists.chisquare.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.quantile( 0.3, 0.0 )\ny = base.dists.chisquare.quantile( 0.9, 0.0 )\n"
+base.dists.chisquare.skewness,"var v = base.dists.chisquare.skewness( 11.0 )\nv = base.dists.chisquare.skewness( 1.5 )\n"
+base.dists.chisquare.stdev,"var v = base.dists.chisquare.stdev( 11.0 )\nv = base.dists.chisquare.stdev( 1.5 )\n"
+base.dists.chisquare.variance,"var v = base.dists.chisquare.variance( 11.0 )\nv = base.dists.chisquare.variance( 1.5 )\n"
+base.dists.cosine.cdf,"var y = base.dists.cosine.cdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.cdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.cdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 10.0, 8.0, 0.0 )\n"
+base.dists.cosine.Cosine,"var cosine = base.dists.cosine.Cosine( -2.0, 3.0 );\ncosine.mu\ncosine.s\ncosine.kurtosis\ncosine.mean\ncosine.median\ncosine.mode\ncosine.skewness\ncosine.stdev\ncosine.variance\ncosine.cdf( 0.5 )\ncosine.logcdf( 0.5 )\ncosine.logpdf( -1.0 )\ncosine.mgf( 0.2 )\ncosine.pdf( -2.0 )\ncosine.quantile( 0.9 )\n"
+base.dists.cosine.kurtosis,"var y = base.dists.cosine.kurtosis( 0.0, 1.0 )\ny = base.dists.cosine.kurtosis( 4.0, 2.0 )\ny = base.dists.cosine.kurtosis( NaN, 1.0 )\ny = base.dists.cosine.kurtosis( 0.0, NaN )\ny = base.dists.cosine.kurtosis( 0.0, 0.0 )\n"
+base.dists.cosine.logcdf,"var y = base.dists.cosine.logcdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.logcdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.logcdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.logcdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.logcdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 10.0, 8.0, 0.0 )\n"
+base.dists.cosine.logpdf,"var y = base.dists.cosine.logpdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logpdf( -1.0, 2.0, 4.0 )\ny = base.dists.cosine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.cosine.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logpdf( 8.0, 8.0, 0.0 )\n"
+base.dists.cosine.mean,"var y = base.dists.cosine.mean( 0.0, 1.0 )\ny = base.dists.cosine.mean( 4.0, 2.0 )\ny = base.dists.cosine.mean( NaN, 1.0 )\ny = base.dists.cosine.mean( 0.0, NaN )\ny = base.dists.cosine.mean( 0.0, 0.0 )\n"
+base.dists.cosine.median,"var y = base.dists.cosine.median( 0.0, 1.0 )\ny = base.dists.cosine.median( 4.0, 2.0 )\ny = base.dists.cosine.median( NaN, 1.0 )\ny = base.dists.cosine.median( 0.0, NaN )\ny = base.dists.cosine.median( 0.0, 0.0 )\n"
+base.dists.cosine.mgf,"var y = base.dists.cosine.mgf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.mgf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.mgf( 0.5, 0.0, NaN )\ny = base.dists.cosine.mgf( 0.5, NaN, 1.0 )\ny = base.dists.cosine.mgf( NaN, 0.0, 1.0 )\n"
+base.dists.cosine.mode,"var y = base.dists.cosine.mode( 0.0, 1.0 )\ny = base.dists.cosine.mode( 4.0, 2.0 )\ny = base.dists.cosine.mode( NaN, 1.0 )\ny = base.dists.cosine.mode( 0.0, NaN )\ny = base.dists.cosine.mode( 0.0, 0.0 )\n"
+base.dists.cosine.pdf,"var y = base.dists.cosine.pdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.pdf( 2.4, 4.0, 2.0 )\ny = base.dists.cosine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.cosine.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.pdf( 8.0, 8.0, 0.0 )\n"
+base.dists.cosine.quantile,"var y = base.dists.cosine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.cosine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cosine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cosine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cosine.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.cosine.skewness,"var y = base.dists.cosine.skewness( 0.0, 1.0 )\ny = base.dists.cosine.skewness( 4.0, 2.0 )\ny = base.dists.cosine.skewness( NaN, 1.0 )\ny = base.dists.cosine.skewness( 0.0, NaN )\ny = base.dists.cosine.skewness( 0.0, 0.0 )\n"
+base.dists.cosine.stdev,"var y = base.dists.cosine.stdev( 0.0, 1.0 )\ny = base.dists.cosine.stdev( 4.0, 2.0 )\ny = base.dists.cosine.stdev( NaN, 1.0 )\ny = base.dists.cosine.stdev( 0.0, NaN )\ny = base.dists.cosine.stdev( 0.0, 0.0 )\n"
+base.dists.cosine.variance,"var y = base.dists.cosine.variance( 0.0, 1.0 )\ny = base.dists.cosine.variance( 4.0, 2.0 )\ny = base.dists.cosine.variance( NaN, 1.0 )\ny = base.dists.cosine.variance( 0.0, NaN )\ny = base.dists.cosine.variance( 0.0, 0.0 )\n"
+base.dists.degenerate.cdf,"var y = base.dists.degenerate.cdf( 2.0, 3.0 )\ny = base.dists.degenerate.cdf( 4.0, 3.0 )\ny = base.dists.degenerate.cdf( 3.0, 3.0 )\ny = base.dists.degenerate.cdf( NaN, 0.0 )\ny = base.dists.degenerate.cdf( 0.0, NaN )\n"
+base.dists.degenerate.Degenerate,"var degenerate = base.dists.degenerate.Degenerate( 2.0 );\ndegenerate.mu\ndegenerate.entropy\ndegenerate.mean\ndegenerate.mode\ndegenerate.median\ndegenerate.stdev\ndegenerate.variance\ndegenerate.cdf( 0.5 )\ndegenerate.logcdf( 2.5 )\ndegenerate.logpdf( 0.5 )\ndegenerate.logpmf( 2.5 )\ndegenerate.mgf( 0.2 )\ndegenerate.pdf( 2.0 )\ndegenerate.pmf( 2.0 )\ndegenerate.quantile( 0.7 )\n"
+base.dists.degenerate.entropy,"var v = base.dists.degenerate.entropy( 20.0 )\nv = base.dists.degenerate.entropy( -10.0 )\n"
+base.dists.degenerate.logcdf,"var y = base.dists.degenerate.logcdf( 2.0, 3.0 )\ny = base.dists.degenerate.logcdf( 4.0, 3.0 )\ny = base.dists.degenerate.logcdf( 3.0, 3.0 )\ny = base.dists.degenerate.logcdf( NaN, 0.0 )\ny = base.dists.degenerate.logcdf( 0.0, NaN )\n"
+base.dists.degenerate.logpdf,"var y = base.dists.degenerate.logpdf( 2.0, 3.0 )\ny = base.dists.degenerate.logpdf( 3.0, 3.0 )\ny = base.dists.degenerate.logpdf( NaN, 0.0 )\ny = base.dists.degenerate.logpdf( 0.0, NaN )\n"
+base.dists.degenerate.logpmf,"var y = base.dists.degenerate.logpmf( 2.0, 3.0 )\ny = base.dists.degenerate.logpmf( 3.0, 3.0 )\ny = base.dists.degenerate.logpmf( NaN, 0.0 )\ny = base.dists.degenerate.logpmf( 0.0, NaN )\n"
+base.dists.degenerate.mean,"var v = base.dists.degenerate.mean( 20.0 )\nv = base.dists.degenerate.mean( -10.0 )\n"
+base.dists.degenerate.median,"var v = base.dists.degenerate.median( 20.0 )\nv = base.dists.degenerate.median( -10.0 )\n"
+base.dists.degenerate.mgf,"var y = base.dists.degenerate.mgf( 1.0, 1.0 )\ny = base.dists.degenerate.mgf( 2.0, 3.0 )\ny = base.dists.degenerate.mgf( NaN, 0.0 )\ny = base.dists.degenerate.mgf( 0.0, NaN )\n"
+base.dists.degenerate.mode,"var v = base.dists.degenerate.mode( 20.0 )\nv = base.dists.degenerate.mode( -10.0 )\n"
+base.dists.degenerate.pdf,"var y = base.dists.degenerate.pdf( 2.0, 3.0 )\ny = base.dists.degenerate.pdf( 3.0, 3.0 )\ny = base.dists.degenerate.pdf( NaN, 0.0 )\ny = base.dists.degenerate.pdf( 0.0, NaN )\n"
+base.dists.degenerate.pmf,"var y = base.dists.degenerate.pmf( 2.0, 3.0 )\ny = base.dists.degenerate.pmf( 3.0, 3.0 )\ny = base.dists.degenerate.pmf( NaN, 0.0 )\ny = base.dists.degenerate.pmf( 0.0, NaN )\n"
+base.dists.degenerate.quantile,"var y = base.dists.degenerate.quantile( 0.5, 2.0 )\ny = base.dists.degenerate.quantile( 0.9, 4.0 )\ny = base.dists.degenerate.quantile( 1.1, 0.0 )\ny = base.dists.degenerate.quantile( -0.2, 0.0 )\ny = base.dists.degenerate.quantile( NaN, 0.0 )\ny = base.dists.degenerate.quantile( 0.0, NaN )\n"
+base.dists.degenerate.stdev,"var v = base.dists.degenerate.stdev( 20.0 )\nv = base.dists.degenerate.stdev( -10.0 )\n"
+base.dists.degenerate.variance,"var v = base.dists.degenerate.variance( 20.0 )\nv = base.dists.degenerate.variance( -10.0 )\n"
+base.dists.discreteUniform.cdf,"var y = base.dists.discreteUniform.cdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.cdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.cdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.cdf( 2.0, 1, 0 )\n"
+base.dists.discreteUniform.DiscreteUniform,"var discreteUniform = base.dists.discreteUniform.DiscreteUniform( -2, 2 );\ndiscreteUniform.a\ndiscreteUniform.b\ndiscreteUniform.entropy\ndiscreteUniform.kurtosis\ndiscreteUniform.mean\ndiscreteUniform.median\ndiscreteUniform.skewness\ndiscreteUniform.stdev\ndiscreteUniform.variance\ndiscreteUniform.cdf( 0.8 )\ndiscreteUniform.logcdf( 0.5 )\ndiscreteUniform.logpmf( 1.0 )\ndiscreteUniform.mgf( 0.8 )\ndiscreteUniform.pmf( 0.0 )\ndiscreteUniform.quantile( 0.8 )\n"
+base.dists.discreteUniform.kurtosis,"var v = base.dists.discreteUniform.kurtosis( 0, 1 )\nv = base.dists.discreteUniform.kurtosis( 4, 12 )\nv = base.dists.discreteUniform.kurtosis( -4, 8 )\n"
+base.dists.discreteUniform.logcdf,"var y = base.dists.discreteUniform.logcdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.logcdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.logcdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logcdf( 2.0, 1, 0 )\n"
+base.dists.discreteUniform.logpmf,"var y = base.dists.discreteUniform.logpmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.logpmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logpmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.logpmf( 2.0, 1, 2.4 )\n"
+base.dists.discreteUniform.mean,"var v = base.dists.discreteUniform.mean( -2, 2 )\nv = base.dists.discreteUniform.mean( 4, 12 )\nv = base.dists.discreteUniform.mean( 2, 8 )\n"
+base.dists.discreteUniform.median,"var v = base.dists.discreteUniform.median( -2, 2 )\nv = base.dists.discreteUniform.median( 4, 12 )\nv = base.dists.discreteUniform.median( 2, 8 )\n"
+base.dists.discreteUniform.mgf,"var y = base.dists.discreteUniform.mgf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.mgf( -0.2, 0, 4 )\ny = base.dists.discreteUniform.mgf( 2.0, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.5, 3, 2 )\ny = base.dists.discreteUniform.mgf( NaN, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, 0, NaN )\n"
+base.dists.discreteUniform.pmf,"var y = base.dists.discreteUniform.pmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.pmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.pmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.pmf( 2.0, 1, 2.4 )\n"
+base.dists.discreteUniform.quantile,"var y = base.dists.discreteUniform.quantile( 0.8, 0, 1 )\ny = base.dists.discreteUniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.discreteUniform.quantile( 1.1, 0, 4 )\ny = base.dists.discreteUniform.quantile( -0.2, 0, 4 )\ny = base.dists.discreteUniform.quantile( NaN, -2, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, NaN, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, -2, NaN )\ny = base.dists.discreteUniform.quantile( 0.5, 2, 1 )\n"
+base.dists.discreteUniform.skewness,"var v = base.dists.discreteUniform.skewness( -2, 2 )\nv = base.dists.discreteUniform.skewness( 4, 12 )\nv = base.dists.discreteUniform.skewness( 2, 8 )\n"
+base.dists.discreteUniform.stdev,"var v = base.dists.discreteUniform.stdev( 0, 1 )\nv = base.dists.discreteUniform.stdev( 4, 12 )\nv = base.dists.discreteUniform.stdev( 2, 8 )\n"
+base.dists.discreteUniform.variance,"var v = base.dists.discreteUniform.variance( 0, 1 )\nv = base.dists.discreteUniform.variance( 4, 12 )\nv = base.dists.discreteUniform.variance( 2, 8 )\n"
+base.dists.erlang.cdf,"var y = base.dists.erlang.cdf( 2.0, 1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 3, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 2.5, 1.0 )\ny = base.dists.erlang.cdf( -1.0, 2, 2.0 )\ny = base.dists.erlang.cdf( PINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NaN, 0, 1.0 )\ny = base.dists.erlang.cdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.cdf( 0.0, 0, NaN )\ny = base.dists.erlang.cdf( 2.0, -1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 1, -1.0 )\n"
+base.dists.erlang.entropy,"var v = base.dists.erlang.entropy( 1, 1.0 )\nv = base.dists.erlang.entropy( 4, 12.0 )\nv = base.dists.erlang.entropy( 8, 2.0 )\n"
+base.dists.erlang.Erlang,"var erlang = base.dists.erlang.Erlang( 6, 5.0 );\nerlang.k\nerlang.lambda\nerlang.entropy\nerlang.kurtosis\nerlang.mean\nerlang.mode\nerlang.skewness\nerlang.stdev\nerlang.variance\nerlang.cdf( 3.0 )\nerlang.logpdf( 3.0 )\nerlang.mgf( -0.5 )\nerlang.pdf( 3.0 )\nerlang.quantile( 0.8 )\n"
+base.dists.erlang.kurtosis,"var v = base.dists.erlang.kurtosis( 1, 1.0 )\nv = base.dists.erlang.kurtosis( 4, 12.0 )\nv = base.dists.erlang.kurtosis( 8, 2.0 )\n"
+base.dists.erlang.logpdf,"var y = base.dists.erlang.logpdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.logpdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.logpdf( NaN, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, 1, NaN )\ny = base.dists.erlang.logpdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, -1.0 )\n"
+base.dists.erlang.mean,"var v = base.dists.erlang.mean( 1, 1.0 )\nv = base.dists.erlang.mean( 4, 12.0 )\nv = base.dists.erlang.mean( 8, 2.0 )\n"
+base.dists.erlang.mgf,"var y = base.dists.erlang.mgf( 0.3, 1, 1.0 )\ny = base.dists.erlang.mgf( 2.0, 2, 3.0 )\ny = base.dists.erlang.mgf( -1.0, 2, 2.0 )\ny = base.dists.erlang.mgf( NaN, 1, 1.0 )\ny = base.dists.erlang.mgf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.mgf( 0.0, 1, NaN )\ny = base.dists.erlang.mgf( 0.2, -2, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 0.5, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 1, 0.0 )\ny = base.dists.erlang.mgf( 0.2, 1, -5.0 )\n"
+base.dists.erlang.mode,"var v = base.dists.erlang.mode( 1, 1.0 )\nv = base.dists.erlang.mode( 4, 12.0 )\nv = base.dists.erlang.mode( 8, 2.0 )\n"
+base.dists.erlang.pdf,"var y = base.dists.erlang.pdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.pdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.pdf( NaN, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.pdf( 0.0, 1, NaN )\ny = base.dists.erlang.pdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.pdf( 2.0, 1, -1.0 )\n"
+base.dists.erlang.quantile,"var y = base.dists.erlang.quantile( 0.8, 2, 1.0 )\ny = base.dists.erlang.quantile( 0.5, 4, 2.0 )\ny = base.dists.erlang.quantile( 1.1, 1, 1.0 )\ny = base.dists.erlang.quantile( -0.2, 1, 1.0 )\ny = base.dists.erlang.quantile( NaN, 1, 1.0 )\ny = base.dists.erlang.quantile( 0.0, NaN, 1.0 )\ny = base.dists.erlang.quantile( 0.0, 1, NaN )\n\n// Non-integer shape parameter:\ny = base.dists.erlang.quantile( 0.5, 0.5, 1.0 )\n\n// Non-positive shape parameter:\ny = base.dists.erlang.quantile( 0.5, -1, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.erlang.quantile( 0.5, 1, -1.0 )\n"
+base.dists.erlang.skewness,"var v = base.dists.erlang.skewness( 1, 1.0 )\nv = base.dists.erlang.skewness( 4, 12.0 )\nv = base.dists.erlang.skewness( 8, 2.0 )\n"
+base.dists.erlang.stdev,"var v = base.dists.erlang.stdev( 1, 1.0 )\nv = base.dists.erlang.stdev( 4, 12.0 )\nv = base.dists.erlang.stdev( 8, 2.0 )\n"
+base.dists.erlang.variance,"var v = base.dists.erlang.variance( 1, 1.0 )\nv = base.dists.erlang.variance( 4, 12.0 )\nv = base.dists.erlang.variance( 8, 2.0 )\n"
+base.dists.exponential.cdf,"var y = base.dists.exponential.cdf( 2.0, 0.1 )\ny = base.dists.exponential.cdf( 1.0, 2.0 )\ny = base.dists.exponential.cdf( -1.0, 4.0 )\ny = base.dists.exponential.cdf( NaN, 1.0 )\ny = base.dists.exponential.cdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.cdf( 2.0, -1.0 )\n"
+base.dists.exponential.entropy,"var v = base.dists.exponential.entropy( 11.0 )\nv = base.dists.exponential.entropy( 4.5 )\n"
+base.dists.exponential.Exponential,"var exponential = base.dists.exponential.Exponential( 6.0 );\nexponential.lambda\nexponential.entropy\nexponential.kurtosis\nexponential.mean\nexponential.median\nexponential.mode\nexponential.skewness\nexponential.stdev\nexponential.variance\nexponential.cdf( 1.0 )\nexponential.logcdf( 1.0 )\nexponential.logpdf( 1.5 )\nexponential.mgf( -0.5 )\nexponential.pdf( 1.5 )\nexponential.quantile( 0.5 )\n"
+base.dists.exponential.kurtosis,"var v = base.dists.exponential.kurtosis( 11.0 )\nv = base.dists.exponential.kurtosis( 4.5 )\n"
+base.dists.exponential.logcdf,"var y = base.dists.exponential.logcdf( 2.0, 0.1 )\ny = base.dists.exponential.logcdf( 1.0, 2.0 )\ny = base.dists.exponential.logcdf( -1.0, 4.0 )\ny = base.dists.exponential.logcdf( NaN, 1.0 )\ny = base.dists.exponential.logcdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.logcdf( 2.0, -1.0 )\n"
+base.dists.exponential.logpdf,"var y = base.dists.exponential.logpdf( 0.3, 4.0 )\ny = base.dists.exponential.logpdf( 2.0, 0.7 )\ny = base.dists.exponential.logpdf( -1.0, 0.5 )\ny = base.dists.exponential.logpdf( 0, NaN )\ny = base.dists.exponential.logpdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.logpdf( 2.0, -1.0 )\n"
+base.dists.exponential.mean,"var v = base.dists.exponential.mean( 11.0 )\nv = base.dists.exponential.mean( 4.5 )\n"
+base.dists.exponential.median,"var v = base.dists.exponential.median( 11.0 )\nv = base.dists.exponential.median( 4.5 )\n"
+base.dists.exponential.mode,"var v = base.dists.exponential.mode( 11.0 )\nv = base.dists.exponential.mode( 4.5 )\n"
+base.dists.exponential.pdf,"var y = base.dists.exponential.pdf( 0.3, 4.0 )\ny = base.dists.exponential.pdf( 2.0, 0.7 )\ny = base.dists.exponential.pdf( -1.0, 0.5 )\ny = base.dists.exponential.pdf( 0, NaN )\ny = base.dists.exponential.pdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.pdf( 2.0, -1.0 )\n"
+base.dists.exponential.quantile,"var y = base.dists.exponential.quantile( 0.8, 1.0 )\ny = base.dists.exponential.quantile( 0.5, 4.0 )\ny = base.dists.exponential.quantile( 0.5, 0.1 )\ny = base.dists.exponential.quantile( -0.2, 0.1 )\ny = base.dists.exponential.quantile( NaN, 1.0 )\ny = base.dists.exponential.quantile( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.quantile( 0.5, -1.0 )\n"
+base.dists.exponential.skewness,"var v = base.dists.exponential.skewness( 11.0 )\nv = base.dists.exponential.skewness( 4.5 )\n"
+base.dists.exponential.stdev,"var v = base.dists.exponential.stdev( 9.0 )\nv = base.dists.exponential.stdev( 1.0 )\n"
+base.dists.exponential.variance,"var v = base.dists.exponential.variance( 9.0 )\nv = base.dists.exponential.variance( 1.0 )\n"
+base.dists.f.cdf,"var y = base.dists.f.cdf( 2.0, 1.0, 1.0 )\nvar y = base.dists.f.cdf( 2.0, 8.0, 4.0 )\nvar y = base.dists.f.cdf( -1.0, 2.0, 2.0 )\nvar y = base.dists.f.cdf( PINF, 4.0, 2.0 )\nvar y = base.dists.f.cdf( NINF, 4.0, 2.0 )\nvar y = base.dists.f.cdf( NaN, 1.0, 1.0 )\nvar y = base.dists.f.cdf( 0.0, NaN, 1.0 )\nvar y = base.dists.f.cdf( 0.0, 1.0, NaN )\nvar y = base.dists.f.cdf( 2.0, 1.0, -1.0 )\nvar y = base.dists.f.cdf( 2.0, -1.0, 1.0 )\n"
+base.dists.f.entropy,"var v = base.dists.f.entropy( 3.0, 7.0 )\nv = base.dists.f.entropy( 4.0, 12.0 )\nv = base.dists.f.entropy( 8.0, 2.0 )\n"
+base.dists.f.F,"var f = base.dists.f.F( 6.0, 9.0 );\nf.d1\nf.d2\nf.entropy\nf.kurtosis\nf.mean\nf.mode\nf.skewness\nf.stdev\nf.variance\nf.cdf( 3.0 )\nf.pdf( 2.5 )\nf.quantile( 0.8 )\n"
+base.dists.f.kurtosis,"var v = base.dists.f.kurtosis( 3.0, 9.0 )\nv = base.dists.f.kurtosis( 4.0, 12.0 )\nv = base.dists.f.kurtosis( 8.0, 9.0 )\n"
+base.dists.f.mean,"var v = base.dists.f.mean( 3.0, 5.0 )\nv = base.dists.f.mean( 4.0, 12.0 )\nv = base.dists.f.mean( 8.0, 4.0 )\n"
+base.dists.f.mode,"var v = base.dists.f.mode( 3.0, 5.0 )\nv = base.dists.f.mode( 4.0, 12.0 )\nv = base.dists.f.mode( 8.0, 4.0 )\n"
+base.dists.f.pdf,"var y = base.dists.f.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.f.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.f.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.f.pdf( NaN, 1.0, 1.0 )\ny = base.dists.f.pdf( 0.0, NaN, 1.0 )\ny = base.dists.f.pdf( 0.0, 1.0, NaN )\ny = base.dists.f.pdf( 2.0, 1.0, -1.0 )\ny = base.dists.f.pdf( 2.0, -1.0, 1.0 )\n"
+base.dists.f.quantile,"var y = base.dists.f.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.f.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.f.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.f.quantile( NaN, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, NaN, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, NaN )\ny = base.dists.f.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.f.skewness,"var v = base.dists.f.skewness( 3.0, 7.0 )\nv = base.dists.f.skewness( 4.0, 12.0 )\nv = base.dists.f.skewness( 8.0, 7.0 )\n"
+base.dists.f.stdev,"var v = base.dists.f.stdev( 3.0, 5.0 )\nv = base.dists.f.stdev( 4.0, 12.0 )\nv = base.dists.f.stdev( 8.0, 5.0 )\n"
+base.dists.f.variance,"var v = base.dists.f.variance( 3.0, 5.0 )\nv = base.dists.f.variance( 4.0, 12.0 )\nv = base.dists.f.variance( 8.0, 5.0 )\n"
+base.dists.frechet.cdf,"var y = base.dists.frechet.cdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.cdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.cdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.cdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.cdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, -1.0, 0.0 )\n"
+base.dists.frechet.entropy,"var y = base.dists.frechet.entropy( 1.0, 1.0, 1.0 )\ny = base.dists.frechet.entropy( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.entropy( NaN, 1.0, 0.0 )\ny = base.dists.frechet.entropy( 1.0, NaN, 0.0 )\ny = base.dists.frechet.entropy( 1.0, 1.0, NaN )\n"
+base.dists.frechet.Frechet,"var frechet = base.dists.frechet.Frechet( 1.0, 1.0, 0.0 );\nfrechet.alpha\nfrechet.s\nfrechet.m\nfrechet.entropy\nfrechet.kurtosis\nfrechet.mean\nfrechet.median\nfrechet.mode\nfrechet.skewness\nfrechet.stdev\nfrechet.variance\nfrechet.cdf( 0.8 )\nfrechet.logcdf( 0.8 )\nfrechet.logpdf( 0.8 )\nfrechet.pdf( 0.8 )\nfrechet.quantile( 0.8 )\n"
+base.dists.frechet.kurtosis,"var y = base.dists.frechet.kurtosis( 5.0, 2.0, 1.0 )\nvar y = base.dists.frechet.kurtosis( 5.0, 10.0, -3.0 )\ny = base.dists.frechet.kurtosis( 3.5, 2.0, 1.0 )\ny = base.dists.frechet.kurtosis( NaN, 1.0, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, NaN, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, 1.0, NaN )\n"
+base.dists.frechet.logcdf,"var y = base.dists.frechet.logcdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.logcdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.logcdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.logcdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.logcdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, -1.0, 0.0 )\n"
+base.dists.frechet.logpdf,"var y = base.dists.frechet.logpdf( 10.0, 1.0, 3.0, 5.0 )\ny = base.dists.frechet.logpdf( -2.0, 1.0, 3.0, -3.0 )\ny = base.dists.frechet.logpdf( 0.0, 2.0, 1.0, -1.0 )\ny = base.dists.frechet.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.logpdf( 0.0, 0.0, -1.0 )\n"
+base.dists.frechet.mean,"var y = base.dists.frechet.mean( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.mean( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mean( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mean( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mean( 1.0, 1.0, NaN )\n"
+base.dists.frechet.median,"var y = base.dists.frechet.median( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.median( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.median( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.median( NaN, 1.0, 0.0 )\ny = base.dists.frechet.median( 1.0, NaN, 0.0 )\ny = base.dists.frechet.median( 1.0, 1.0, NaN )\n"
+base.dists.frechet.mode,"var y = base.dists.frechet.mode( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.mode( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.mode( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mode( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mode( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mode( 1.0, 1.0, NaN )\n"
+base.dists.frechet.pdf,"var y = base.dists.frechet.pdf( 10.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( -2.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.frechet.pdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.pdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.pdf( 0.0, 0.0, -1.0 )\n"
+base.dists.frechet.quantile,"var y = base.dists.frechet.quantile( 0.3, 10.0, 2.0, 3.0 )\ny = base.dists.frechet.quantile( 0.2, 3.0, 3.0, 3.0 )\ny = base.dists.frechet.quantile( 0.9, 1.0, 1.0, -3.0 )\ny = base.dists.frechet.quantile( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, NaN, 1.0, 0.0)\ny = base.dists.frechet.quantile( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.quantile( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, -1.0, 0.0 )\n"
+base.dists.frechet.skewness,"var y = base.dists.frechet.skewness( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.skewness( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.skewness( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.skewness( NaN, 1.0, 0.0 )\ny = base.dists.frechet.skewness( 1.0, NaN, 0.0 )\ny = base.dists.frechet.skewness( 1.0, 1.0, NaN )\n"
+base.dists.frechet.stdev,"var y = base.dists.frechet.stdev( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.stdev( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.stdev( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.stdev( NaN, 1.0, 0.0 )\ny = base.dists.frechet.stdev( 1.0, NaN, 0.0 )\ny = base.dists.frechet.stdev( 1.0, 1.0, NaN )\n"
+base.dists.frechet.variance,"var y = base.dists.frechet.variance( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.variance( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.variance( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.variance( NaN, 1.0, 0.0 )\ny = base.dists.frechet.variance( 1.0, NaN, 0.0 )\ny = base.dists.frechet.variance( 1.0, 1.0, NaN )\n"
+base.dists.gamma.cdf,"var y = base.dists.gamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.gamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.gamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.gamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0` when `α = 0.0`:\ny = base.dists.gamma.cdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( -2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, 2.0 )\n"
+base.dists.gamma.entropy,"var v = base.dists.gamma.entropy( 1.0, 1.0 )\nv = base.dists.gamma.entropy( 4.0, 12.0 )\nv = base.dists.gamma.entropy( 8.0, 2.0 )\n"
+base.dists.gamma.Gamma,"var gamma = base.dists.gamma.Gamma( 6.0, 5.0 );\ngamma.alpha\ngamma.beta\ngamma.entropy\ngamma.kurtosis\ngamma.mean\ngamma.mode\ngamma.skewness\ngamma.stdev\ngamma.variance\ngamma.cdf( 0.8 )\ngamma.logpdf( 1.0 )\ngamma.mgf( -0.5 )\ngamma.pdf( 1.0 )\ngamma.quantile( 0.8 )\n"
+base.dists.gamma.kurtosis,"var v = base.dists.gamma.kurtosis( 1.0, 1.0 )\nv = base.dists.gamma.kurtosis( 4.0, 12.0 )\nv = base.dists.gamma.kurtosis( 8.0, 2.0 )\n"
+base.dists.gamma.logpdf,"var y = base.dists.gamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.logpdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.logpdf( 0.0, 0.0, 2.0 )\n"
+base.dists.gamma.mean,"var v = base.dists.gamma.mean( 1.0, 1.0 )\nv = base.dists.gamma.mean( 4.0, 12.0 )\nv = base.dists.gamma.mean( 8.0, 2.0 )\n"
+base.dists.gamma.mgf,"var y = base.dists.gamma.mgf( 0.5, 0.5, 1.0 )\ny = base.dists.gamma.mgf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.mgf( NaN, 1.0, 1.0 )\ny = base.dists.gamma.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.mgf( 0.0, 1.0, NaN )\ny = base.dists.gamma.mgf( 2.0, 4.0, 1.0 )\ny = base.dists.gamma.mgf( 2.0, -0.5, 1.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, 0.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, -1.0 )\n"
+base.dists.gamma.mode,"var v = base.dists.gamma.mode( 1.0, 1.0 )\nv = base.dists.gamma.mode( 4.0, 12.0 )\nv = base.dists.gamma.mode( 8.0, 2.0 )\n"
+base.dists.gamma.pdf,"var y = base.dists.gamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.pdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.pdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.pdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.pdf( 0.0, 0.0, 2.0 )\n"
+base.dists.gamma.quantile,"var y = base.dists.gamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.gamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.gamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.gamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.gamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.gamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.quantile( 0.5, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.quantile( 0.3, 0.0, 2.0 )\ny = base.dists.gamma.quantile( 0.9, 0.0, 2.0 )\n"
+base.dists.gamma.skewness,"var v = base.dists.gamma.skewness( 1.0, 1.0 )\nv = base.dists.gamma.skewness( 4.0, 12.0 )\nv = base.dists.gamma.skewness( 8.0, 2.0 )\n"
+base.dists.gamma.stdev,"var v = base.dists.gamma.stdev( 1.0, 1.0 )\nv = base.dists.gamma.stdev( 4.0, 12.0 )\nv = base.dists.gamma.stdev( 8.0, 2.0 )\n"
+base.dists.gamma.variance,"var v = base.dists.gamma.variance( 1.0, 1.0 )\nv = base.dists.gamma.variance( 4.0, 12.0 )\nv = base.dists.gamma.variance( 8.0, 2.0 )\n"
+base.dists.geometric.cdf,"var y = base.dists.geometric.cdf( 2.0, 0.5 )\ny = base.dists.geometric.cdf( 2.0, 0.1 )\ny = base.dists.geometric.cdf( -1.0, 4.0 )\ny = base.dists.geometric.cdf( NaN, 0.5 )\ny = base.dists.geometric.cdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.cdf( 2.0, 1.4 )\n"
+base.dists.geometric.entropy,"var v = base.dists.geometric.entropy( 0.1 )\nv = base.dists.geometric.entropy( 0.5 )\n"
+base.dists.geometric.Geometric,"var geometric = base.dists.geometric.Geometric( 0.6 );\ngeometric.p\ngeometric.entropy\ngeometric.kurtosis\ngeometric.mean\ngeometric.median\ngeometric.mode\ngeometric.skewness\ngeometric.stdev\ngeometric.variance\ngeometric.cdf( 3.0 )\ngeometric.logcdf( 3.0 )\ngeometric.logpmf( 4.0 )\ngeometric.mgf( 0.5 )\ngeometric.pmf( 2.0 )\ngeometric.quantile( 0.7 )\n"
+base.dists.geometric.kurtosis,"var v = base.dists.geometric.kurtosis( 0.1 )\nv = base.dists.geometric.kurtosis( 0.5 )\n"
+base.dists.geometric.logcdf,"var y = base.dists.geometric.logcdf( 2.0, 0.5 )\ny = base.dists.geometric.logcdf( 2.0, 0.1 )\ny = base.dists.geometric.logcdf( -1.0, 4.0 )\ny = base.dists.geometric.logcdf( NaN, 0.5 )\ny = base.dists.geometric.logcdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.logcdf( 2.0, 1.4 )\n"
+base.dists.geometric.logpmf,"var y = base.dists.geometric.logpmf( 4.0, 0.3 )\ny = base.dists.geometric.logpmf( 2.0, 0.7 )\ny = base.dists.geometric.logpmf( -1.0, 0.5 )\ny = base.dists.geometric.logpmf( 0.0, NaN )\ny = base.dists.geometric.logpmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.logpmf( 2.0, 1.5 )\n"
+base.dists.geometric.mean,"var v = base.dists.geometric.mean( 0.1 )\nv = base.dists.geometric.mean( 0.5 )\n"
+base.dists.geometric.median,"var v = base.dists.geometric.median( 0.1 )\nv = base.dists.geometric.median( 0.5 )\n"
+base.dists.geometric.mgf,"var y = base.dists.geometric.mgf( 0.2, 0.5 )\ny = base.dists.geometric.mgf( 0.4, 0.5 )\n\n// Case: t >= -ln(1-p)\ny = base.dists.geometric.mgf( 0.8, 0.5 )\ny = base.dists.geometric.mgf( NaN, 0.0 )\ny = base.dists.geometric.mgf( 0.0, NaN )\ny = base.dists.geometric.mgf( -2.0, -1.0 )\ny = base.dists.geometric.mgf( 0.2, 2.0 )\n"
+base.dists.geometric.mode,"var v = base.dists.geometric.mode( 0.1 )\nv = base.dists.geometric.mode( 0.5 )\n"
+base.dists.geometric.pmf,"var y = base.dists.geometric.pmf( 4.0, 0.3 )\ny = base.dists.geometric.pmf( 2.0, 0.7 )\ny = base.dists.geometric.pmf( -1.0, 0.5 )\ny = base.dists.geometric.pmf( 0.0, NaN )\ny = base.dists.geometric.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.pmf( 2.0, 1.5 )\n"
+base.dists.geometric.quantile,"var y = base.dists.geometric.quantile( 0.8, 0.4 )\ny = base.dists.geometric.quantile( 0.5, 0.4 )\ny = base.dists.geometric.quantile( 0.9, 0.1 )\ny = base.dists.geometric.quantile( -0.2, 0.1 )\ny = base.dists.geometric.quantile( NaN, 0.8 )\ny = base.dists.geometric.quantile( 0.4, NaN )\ny = base.dists.geometric.quantile( 0.5, -1.0 )\ny = base.dists.geometric.quantile( 0.5, 1.5 )\n"
+base.dists.geometric.skewness,"var v = base.dists.geometric.skewness( 0.1 )\nv = base.dists.geometric.skewness( 0.5 )\n"
+base.dists.geometric.stdev,"var v = base.dists.geometric.stdev( 0.1 )\nv = base.dists.geometric.stdev( 0.5 )\n"
+base.dists.geometric.variance,"var v = base.dists.geometric.variance( 0.1 )\nv = base.dists.geometric.variance( 0.5 )\n"
+base.dists.gumbel.cdf,"var y = base.dists.gumbel.cdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.cdf( 0.0, 0.0, -1.0 )\n"
+base.dists.gumbel.entropy,"var y = base.dists.gumbel.entropy( 0.0, 1.0 )\ny = base.dists.gumbel.entropy( 4.0, 2.0 )\ny = base.dists.gumbel.entropy( NaN, 1.0 )\ny = base.dists.gumbel.entropy( 0.0, NaN )\ny = base.dists.gumbel.entropy( 0.0, 0.0 )\n"
+base.dists.gumbel.Gumbel,"var gumbel = base.dists.gumbel.Gumbel( -2.0, 3.0 );\ngumbel.mu\ngumbel.beta\ngumbel.entropy\ngumbel.kurtosis\ngumbel.mean\ngumbel.median\ngumbel.mode\ngumbel.skewness\ngumbel.stdev\ngumbel.variance\ngumbel.cdf( 0.8 )\ngumbel.logcdf( 0.8 )\ngumbel.logpdf( 1.0 )\ngumbel.mgf( 0.2 )\ngumbel.pdf( 1.0 )\ngumbel.quantile( 0.8 )\n"
+base.dists.gumbel.kurtosis,"var y = base.dists.gumbel.kurtosis( 0.0, 1.0 )\ny = base.dists.gumbel.kurtosis( 4.0, 2.0 )\ny = base.dists.gumbel.kurtosis( NaN, 1.0 )\ny = base.dists.gumbel.kurtosis( 0.0, NaN )\ny = base.dists.gumbel.kurtosis( 0.0, 0.0 )\n"
+base.dists.gumbel.logcdf,"var y = base.dists.gumbel.logcdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logcdf( 0.0, 0.0, -1.0 )\n"
+base.dists.gumbel.logpdf,"var y = base.dists.gumbel.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logpdf( 2.0, 0.0, -1.0 )\n"
+base.dists.gumbel.mean,"var y = base.dists.gumbel.mean( 0.0, 1.0 )\ny = base.dists.gumbel.mean( 4.0, 2.0 )\ny = base.dists.gumbel.mean( NaN, 1.0 )\ny = base.dists.gumbel.mean( 0.0, NaN )\ny = base.dists.gumbel.mean( 0.0, 0.0 )\n"
+base.dists.gumbel.median,"var y = base.dists.gumbel.median( 0.0, 1.0 )\ny = base.dists.gumbel.median( 4.0, 2.0 )\ny = base.dists.gumbel.median( NaN, 1.0 )\ny = base.dists.gumbel.median( 0.0, NaN )\ny = base.dists.gumbel.median( 0.0, 0.0 )\n"
+base.dists.gumbel.mgf,"var y = base.dists.gumbel.mgf( -1.0, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.1, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, NaN )\n\n// Case: `t >= 1/beta`\ny = base.dists.gumbel.mgf( 0.8, 0.0, 2.0 )\n\n// Non-positive scale parameter:\ny = base.dists.gumbel.mgf( 0.0, 0.0, -1.0 )\n"
+base.dists.gumbel.mode,"var y = base.dists.gumbel.mode( 0.0, 1.0 )\ny = base.dists.gumbel.mode( 4.0, 2.0 )\ny = base.dists.gumbel.mode( NaN, 1.0 )\ny = base.dists.gumbel.mode( 0.0, NaN )\ny = base.dists.gumbel.mode( 0.0, 0.0 )\n"
+base.dists.gumbel.pdf,"var y = base.dists.gumbel.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.pdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.pdf( 2.0, 0.0, -1.0 )\n"
+base.dists.gumbel.quantile,"var y = base.dists.gumbel.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 4.0 )\ny = base.dists.gumbel.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.gumbel.skewness,"var y = base.dists.gumbel.skewness( 0.0, 1.0 )\ny = base.dists.gumbel.skewness( 4.0, 2.0 )\ny = base.dists.gumbel.skewness( NaN, 1.0 )\ny = base.dists.gumbel.skewness( 0.0, NaN )\ny = base.dists.gumbel.skewness( 0.0, 0.0 )\n"
+base.dists.gumbel.stdev,"var y = base.dists.gumbel.stdev( 0.0, 1.0 )\ny = base.dists.gumbel.stdev( 4.0, 2.0 )\ny = base.dists.gumbel.stdev( NaN, 1.0 )\ny = base.dists.gumbel.stdev( 0.0, NaN )\ny = base.dists.gumbel.stdev( 0.0, 0.0 )\n"
+base.dists.gumbel.variance,"var y = base.dists.gumbel.variance( 0.0, 1.0 )\ny = base.dists.gumbel.variance( 4.0, 2.0 )\ny = base.dists.gumbel.variance( NaN, 1.0 )\ny = base.dists.gumbel.variance( 0.0, NaN )\ny = base.dists.gumbel.variance( 0.0, 0.0 )\n"
+base.dists.hypergeometric.cdf,"var y = base.dists.hypergeometric.cdf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 0, 8, 4, 2)\ny = base.dists.hypergeometric.cdf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.cdf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 1.5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 3, 9 )\n"
+base.dists.hypergeometric.Hypergeometric,"var hypergeometric = base.dists.hypergeometric.Hypergeometric( 100, 70, 20 );\nhypergeometric.N\nhypergeometric.K\nhypergeometric.n\nhypergeometric.kurtosis\nhypergeometric.mean\nhypergeometric.mode\nhypergeometric.skewness\nhypergeometric.stdev\nhypergeometric.variance\nhypergeometric.cdf( 2.9 )\nhypergeometric.logpmf( 10 )\nhypergeometric.pmf( 10 )\nhypergeometric.quantile( 0.8 )\n"
+base.dists.hypergeometric.kurtosis,"var v = base.dists.hypergeometric.kurtosis( 16, 11, 4 )\nv = base.dists.hypergeometric.kurtosis( 4, 2, 2 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 12 )\nv = base.dists.hypergeometric.kurtosis( 10.3, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5.5, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 4.5 )\nv = base.dists.hypergeometric.kurtosis( NaN, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, NaN, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, 10, NaN )\n"
+base.dists.hypergeometric.logpmf,"var y = base.dists.hypergeometric.logpmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.logpmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 3, 9 )\n"
+base.dists.hypergeometric.mean,"var v = base.dists.hypergeometric.mean( 16, 11, 4 )\nv = base.dists.hypergeometric.mean( 2, 1, 1 )\nv = base.dists.hypergeometric.mean( 10, 5, 12 )\nv = base.dists.hypergeometric.mean( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mean( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mean( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mean( NaN, 10, 4 )\nv = base.dists.hypergeometric.mean( 20, NaN, 4 )\nv = base.dists.hypergeometric.mean( 20, 10, NaN )\n"
+base.dists.hypergeometric.mode,"var v = base.dists.hypergeometric.mode( 16, 11, 4 )\nv = base.dists.hypergeometric.mode( 2, 1, 1 )\nv = base.dists.hypergeometric.mode( 10, 5, 12 )\nv = base.dists.hypergeometric.mode( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mode( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mode( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mode( NaN, 10, 4 )\nv = base.dists.hypergeometric.mode( 20, NaN, 4 )\nv = base.dists.hypergeometric.mode( 20, 10, NaN )\n"
+base.dists.hypergeometric.pmf,"var y = base.dists.hypergeometric.pmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.pmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 3, 9 )\n"
+base.dists.hypergeometric.quantile,"var y = base.dists.hypergeometric.quantile( 0.4, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.8, 60, 40, 20 )\ny = base.dists.hypergeometric.quantile( 0.5, 100, 10, 10 )\ny = base.dists.hypergeometric.quantile( 0.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( 1.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( NaN, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, NaN, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, NaN, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, 20, NaN )\n"
+base.dists.hypergeometric.skewness,"var v = base.dists.hypergeometric.skewness( 16, 11, 4 )\nv = base.dists.hypergeometric.skewness( 4, 2, 2 )\nv = base.dists.hypergeometric.skewness( 10, 5, 12 )\nv = base.dists.hypergeometric.skewness( 10.3, 10, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5.5, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5, 4.5 )\nv = base.dists.hypergeometric.skewness( NaN, 10, 4 )\nv = base.dists.hypergeometric.skewness( 20, NaN, 4 )\nv = base.dists.hypergeometric.skewness( 20, 10, NaN )\n"
+base.dists.hypergeometric.stdev,"var v = base.dists.hypergeometric.stdev( 16, 11, 4 )\nv = base.dists.hypergeometric.stdev( 2, 1, 1 )\nv = base.dists.hypergeometric.stdev( 10, 5, 12 )\nv = base.dists.hypergeometric.stdev( 10.3, 10, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5.5, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5, 4.5 )\nv = base.dists.hypergeometric.stdev( NaN, 10, 4 )\nv = base.dists.hypergeometric.stdev( 20, NaN, 4 )\nv = base.dists.hypergeometric.stdev( 20, 10, NaN )\n"
+base.dists.hypergeometric.variance,"var v = base.dists.hypergeometric.variance( 16, 11, 4 )\nv = base.dists.hypergeometric.variance( 2, 1, 1 )\nv = base.dists.hypergeometric.variance( 10, 5, 12 )\nv = base.dists.hypergeometric.variance( 10.3, 10, 4 )\nv = base.dists.hypergeometric.variance( 10, 5.5, 4 )\nv = base.dists.hypergeometric.variance( 10, 5, 4.5 )\nv = base.dists.hypergeometric.variance( NaN, 10, 4 )\nv = base.dists.hypergeometric.variance( 20, NaN, 4 )\nv = base.dists.hypergeometric.variance( 20, 10, NaN )\n"
+base.dists.invgamma.cdf,"var y = base.dists.invgamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.invgamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.invgamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.invgamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 1.0, -1.0 )\n"
+base.dists.invgamma.entropy,"var v = base.dists.invgamma.entropy( 1.0, 1.0 )\nv = base.dists.invgamma.entropy( 4.0, 12.0 )\nv = base.dists.invgamma.entropy( 8.0, 2.0 )\n"
+base.dists.invgamma.InvGamma,"var invgamma = base.dists.invgamma.InvGamma( 6.0, 5.0 );\ninvgamma.alpha\ninvgamma.beta\ninvgamma.entropy\ninvgamma.kurtosis\ninvgamma.mean\ninvgamma.mode\ninvgamma.skewness\ninvgamma.stdev\ninvgamma.variance\ninvgamma.cdf( 0.8 )\ninvgamma.pdf( 1.0 )\ninvgamma.logpdf( 1.0 )\ninvgamma.quantile( 0.8 )\n"
+base.dists.invgamma.kurtosis,"var v = base.dists.invgamma.kurtosis( 7.0, 5.0 )\nv = base.dists.invgamma.kurtosis( 6.0, 12.0 )\nv = base.dists.invgamma.kurtosis( 8.0, 2.0 )\n"
+base.dists.invgamma.logpdf,"var y = base.dists.invgamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.logpdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.logpdf( 2.0, 1.0, -1.0 )\n"
+base.dists.invgamma.mean,"var v = base.dists.invgamma.mean( 4.0, 12.0 )\nv = base.dists.invgamma.mean( 8.0, 2.0 )\n"
+base.dists.invgamma.mode,"var v = base.dists.invgamma.mode( 1.0, 1.0 )\nv = base.dists.invgamma.mode( 4.0, 12.0 )\nv = base.dists.invgamma.mode( 8.0, 2.0 )\n"
+base.dists.invgamma.pdf,"var y = base.dists.invgamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.pdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.pdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.pdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.pdf( 2.0, 1.0, -1.0 )\n"
+base.dists.invgamma.quantile,"var y = base.dists.invgamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.invgamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.invgamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.invgamma.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.invgamma.skewness,"var v = base.dists.invgamma.skewness( 4.0, 12.0 )\nv = base.dists.invgamma.skewness( 8.0, 2.0 )\n"
+base.dists.invgamma.stdev,"var v = base.dists.invgamma.stdev( 5.0, 7.0 )\nv = base.dists.invgamma.stdev( 4.0, 12.0 )\nv = base.dists.invgamma.stdev( 8.0, 2.0 )\n"
+base.dists.invgamma.variance,"var v = base.dists.invgamma.variance( 5.0, 7.0 )\nv = base.dists.invgamma.variance( 4.0, 12.0 )\nv = base.dists.invgamma.variance( 8.0, 2.0 )\n"
+base.dists.kumaraswamy.cdf,"var y = base.dists.kumaraswamy.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.cdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, 1.0, NaN )\n"
+base.dists.kumaraswamy.Kumaraswamy,"var kumaraswamy = base.dists.kumaraswamy.Kumaraswamy( 6.0, 5.0 );\nkumaraswamy.a\nkumaraswamy.b\nkumaraswamy.kurtosis\nkumaraswamy.mean\nkumaraswamy.mode\nkumaraswamy.skewness\nkumaraswamy.stdev\nkumaraswamy.variance\nkumaraswamy.cdf( 0.8 )\nkumaraswamy.pdf( 1.0 )\nkumaraswamy.quantile( 0.8 )\n"
+base.dists.kumaraswamy.kurtosis,"var v = base.dists.kumaraswamy.kurtosis( 1.0, 1.0 )\nv = base.dists.kumaraswamy.kurtosis( 4.0, 12.0 )\nv = base.dists.kumaraswamy.kurtosis( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.logcdf,"var y = base.dists.kumaraswamy.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, 1.0, NaN )\n"
+base.dists.kumaraswamy.logpdf,"var y = base.dists.kumaraswamy.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logpdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, 1.0, NaN )\n"
+base.dists.kumaraswamy.mean,"var v = base.dists.kumaraswamy.mean( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mean( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mean( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.median,"var v = base.dists.kumaraswamy.median( 1.0, 1.0 )\nv = base.dists.kumaraswamy.median( 4.0, 12.0 )\nv = base.dists.kumaraswamy.median( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.mode,"var v = base.dists.kumaraswamy.mode( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mode( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mode( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.pdf,"var y = base.dists.kumaraswamy.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.pdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, 1.0, NaN )\n"
+base.dists.kumaraswamy.quantile,"var y = base.dists.kumaraswamy.quantile( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.quantile( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.quantile( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, 1.0, NaN )\n"
+base.dists.kumaraswamy.skewness,"var v = base.dists.kumaraswamy.skewness( 1.0, 1.0 )\nv = base.dists.kumaraswamy.skewness( 4.0, 12.0 )\nv = base.dists.kumaraswamy.skewness( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.stdev,"var v = base.dists.kumaraswamy.stdev( 1.0, 1.0 )\nv = base.dists.kumaraswamy.stdev( 4.0, 12.0 )\nv = base.dists.kumaraswamy.stdev( 16.0, 8.0 )\n"
+base.dists.kumaraswamy.variance,"var v = base.dists.kumaraswamy.variance( 1.0, 1.0 )\nv = base.dists.kumaraswamy.variance( 4.0, 12.0 )\nv = base.dists.kumaraswamy.variance( 16.0, 8.0 )\n"
+base.dists.laplace.cdf,"var y = base.dists.laplace.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.cdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 2, NaN, 1.0 )\ny = base.dists.laplace.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.cdf( 2.0, 0.0, -1.0 )\n"
+base.dists.laplace.entropy,"var y = base.dists.laplace.entropy( 0.0, 1.0 )\ny = base.dists.laplace.entropy( 4.0, 2.0 )\ny = base.dists.laplace.entropy( NaN, 1.0 )\ny = base.dists.laplace.entropy( 0.0, NaN )\ny = base.dists.laplace.entropy( 0.0, 0.0 )\n"
+base.dists.laplace.kurtosis,"var y = base.dists.laplace.kurtosis( 0.0, 1.0 )\ny = base.dists.laplace.kurtosis( 4.0, 2.0 )\ny = base.dists.laplace.kurtosis( NaN, 1.0 )\ny = base.dists.laplace.kurtosis( 0.0, NaN )\ny = base.dists.laplace.kurtosis( 0.0, 0.0 )\n"
+base.dists.laplace.Laplace,"var laplace = base.dists.laplace.Laplace( -2.0, 3.0 );\nlaplace.mu\nlaplace.b\nlaplace.entropy\nlaplace.kurtosis\nlaplace.mean\nlaplace.median\nlaplace.mode\nlaplace.skewness\nlaplace.stdev\nlaplace.variance\nlaplace.cdf( 0.8 )\nlaplace.logcdf( 0.8 )\nlaplace.logpdf( 1.0 )\nlaplace.mgf( 0.2 )\nlaplace.pdf( 2.0 )\nlaplace.quantile( 0.9 )\n"
+base.dists.laplace.logcdf,"var y = base.dists.laplace.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 2, NaN, 1.0 )\ny = base.dists.laplace.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logcdf( 2.0, 0.0, -1.0 )\n"
+base.dists.laplace.logpdf,"var y = base.dists.laplace.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logpdf( 2.0, 0.0, -1.0 )\n"
+base.dists.laplace.mean,"var y = base.dists.laplace.mean( 0.0, 1.0 )\ny = base.dists.laplace.mean( 4.0, 2.0 )\ny = base.dists.laplace.mean( NaN, 1.0 )\ny = base.dists.laplace.mean( 0.0, NaN )\ny = base.dists.laplace.mean( 0.0, 0.0 )\n"
+base.dists.laplace.median,"var y = base.dists.laplace.median( 0.0, 1.0 )\ny = base.dists.laplace.median( 4.0, 2.0 )\ny = base.dists.laplace.median( NaN, 1.0 )\ny = base.dists.laplace.median( 0.0, NaN )\ny = base.dists.laplace.median( 0.0, 0.0 )\n"
+base.dists.laplace.mgf,"var y = base.dists.laplace.mgf( 0.5, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.laplace.mgf( -1.0, 4.0, 0.2 )\ny = base.dists.laplace.mgf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, NaN )\ny = base.dists.laplace.mgf( 1.0, 0.0, 2.0 )\ny = base.dists.laplace.mgf( -0.5, 0.0, 4.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, 0.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, -1.0 )\n"
+base.dists.laplace.mode,"var y = base.dists.laplace.mode( 0.0, 1.0 )\ny = base.dists.laplace.mode( 4.0, 2.0 )\ny = base.dists.laplace.mode( NaN, 1.0 )\ny = base.dists.laplace.mode( 0.0, NaN )\ny = base.dists.laplace.mode( 0.0, 0.0 )\n"
+base.dists.laplace.pdf,"var y = base.dists.laplace.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.pdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.pdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.pdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.pdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.pdf( 2.0, 0.0, -1.0 )\n"
+base.dists.laplace.quantile,"var y = base.dists.laplace.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.laplace.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.laplace.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.laplace.quantile( NaN, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.0, NaN, 1.0 )\ny = base.dists.laplace.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.laplace.skewness,"var y = base.dists.laplace.skewness( 0.0, 1.0 )\ny = base.dists.laplace.skewness( 4.0, 2.0 )\ny = base.dists.laplace.skewness( NaN, 1.0 )\ny = base.dists.laplace.skewness( 0.0, NaN )\ny = base.dists.laplace.skewness( 0.0, 0.0 )\n"
+base.dists.laplace.stdev,"var y = base.dists.laplace.stdev( 0.0, 1.0 )\ny = base.dists.laplace.stdev( 4.0, 2.0 )\ny = base.dists.laplace.stdev( NaN, 1.0 )\ny = base.dists.laplace.stdev( 0.0, NaN )\ny = base.dists.laplace.stdev( 0.0, 0.0 )\n"
+base.dists.laplace.variance,"var y = base.dists.laplace.variance( 0.0, 1.0 )\ny = base.dists.laplace.variance( 4.0, 2.0 )\ny = base.dists.laplace.variance( NaN, 1.0 )\ny = base.dists.laplace.variance( 0.0, NaN )\ny = base.dists.laplace.variance( 0.0, 0.0 )\n"
+base.dists.levy.cdf,"var y = base.dists.levy.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.cdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.cdf( 2, NaN, 1.0 )\ny = base.dists.levy.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.cdf( 2.0, 0.0, -1.0 )\n"
+base.dists.levy.entropy,"var y = base.dists.levy.entropy( 0.0, 1.0 )\ny = base.dists.levy.entropy( 4.0, 2.0 )\ny = base.dists.levy.entropy( NaN, 1.0 )\ny = base.dists.levy.entropy( 0.0, NaN )\ny = base.dists.levy.entropy( 0.0, 0.0 )\n"
+base.dists.levy.Levy,"var levy = base.dists.levy.Levy( -2.0, 3.0 );\nlevy.mu\nlevy.c\nlevy.entropy\nlevy.mean\nlevy.median\nlevy.mode\nlevy.stdev\nlevy.variance\nlevy.cdf( 0.8 )\nlevy.logcdf( 0.8 )\nlevy.logpdf( 1.0 )\nlevy.pdf( 1.0 )\nlevy.quantile( 0.8 )\n"
+base.dists.levy.logcdf,"var y = base.dists.levy.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 2, NaN, 1.0 )\ny = base.dists.levy.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logcdf( 2.0, 0.0, -1.0 )\n"
+base.dists.levy.logpdf,"var y = base.dists.levy.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logpdf( 2.0, 0.0, -1.0 )\n"
+base.dists.levy.mean,"var y = base.dists.levy.mean( 0.0, 1.0 )\ny = base.dists.levy.mean( 4.0, 3.0 )\ny = base.dists.levy.mean( NaN, 1.0 )\ny = base.dists.levy.mean( 0.0, NaN )\ny = base.dists.levy.mean( 0.0, 0.0 )\n"
+base.dists.levy.median,"var y = base.dists.levy.median( 0.0, 1.0 )\ny = base.dists.levy.median( 4.0, 3.0 )\ny = base.dists.levy.median( NaN, 1.0 )\ny = base.dists.levy.median( 0.0, NaN )\ny = base.dists.levy.median( 0.0, 0.0 )\n"
+base.dists.levy.mode,"var y = base.dists.levy.mode( 0.0, 1.0 )\ny = base.dists.levy.mode( 4.0, 3.0 )\ny = base.dists.levy.mode( NaN, 1.0 )\ny = base.dists.levy.mode( 0.0, NaN )\ny = base.dists.levy.mode( 0.0, 0.0 )\n"
+base.dists.levy.pdf,"var y = base.dists.levy.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.pdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.pdf( 2.0, 0.0, -1.0 )\n"
+base.dists.levy.quantile,"var y = base.dists.levy.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.levy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.levy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.levy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.levy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.levy.stdev,"var y = base.dists.levy.stdev( 0.0, 1.0 )\ny = base.dists.levy.stdev( 4.0, 3.0 )\ny = base.dists.levy.stdev( NaN, 1.0 )\ny = base.dists.levy.stdev( 0.0, NaN )\ny = base.dists.levy.stdev( 0.0, 0.0 )\n"
+base.dists.levy.variance,"var y = base.dists.levy.variance( 0.0, 1.0 )\ny = base.dists.levy.variance( 4.0, 3.0 )\ny = base.dists.levy.variance( NaN, 1.0 )\ny = base.dists.levy.variance( 0.0, NaN )\ny = base.dists.levy.variance( 0.0, 0.0 )\n"
+base.dists.logistic.cdf,"var y = base.dists.logistic.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.cdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.cdf( 2.0, NaN, 1.0 )\ny = base.dists.logistic.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.logistic.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 10.0, 8.0, 0.0 )\n"
+base.dists.logistic.entropy,"var y = base.dists.logistic.entropy( 0.0, 1.0 )\ny = base.dists.logistic.entropy( 4.0, 2.0 )\ny = base.dists.logistic.entropy( NaN, 1.0 )\ny = base.dists.logistic.entropy( 0.0, NaN )\ny = base.dists.logistic.entropy( 0.0, 0.0 )\n"
+base.dists.logistic.kurtosis,"var y = base.dists.logistic.kurtosis( 0.0, 1.0 )\ny = base.dists.logistic.kurtosis( 4.0, 2.0 )\ny = base.dists.logistic.kurtosis( NaN, 1.0 )\ny = base.dists.logistic.kurtosis( 0.0, NaN )\ny = base.dists.logistic.kurtosis( 0.0, 0.0 )\n"
+base.dists.logistic.logcdf,"var y = base.dists.logistic.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.logcdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.logcdf( 2, NaN, 1.0 )\ny = base.dists.logistic.logcdf( NaN, 0.0, 1.0 )\n"
+base.dists.logistic.Logistic,"var logistic = base.dists.logistic.Logistic( -2.0, 3.0 );\nlogistic.mu\nlogistic.s\nlogistic.entropy\nlogistic.kurtosis\nlogistic.mean\nlogistic.median\nlogistic.mode\nlogistic.skewness\nlogistic.stdev\nlogistic.variance\nlogistic.cdf( 0.8 )\nlogistic.logcdf( 0.8 )\nlogistic.logpdf( 2.0 )\nlogistic.mgf( 0.2 )\nlogistic.pdf( 2.0 )\nlogistic.quantile( 0.9 )\n"
+base.dists.logistic.logpdf,"var y = base.dists.logistic.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.logistic.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.logpdf( 8.0, 8.0, 0.0 )\n"
+base.dists.logistic.mean,"var y = base.dists.logistic.mean( 0.0, 1.0 )\ny = base.dists.logistic.mean( 4.0, 2.0 )\ny = base.dists.logistic.mean( NaN, 1.0 )\ny = base.dists.logistic.mean( 0.0, NaN )\ny = base.dists.logistic.mean( 0.0, 0.0 )\n"
+base.dists.logistic.median,"var y = base.dists.logistic.median( 0.0, 1.0 )\ny = base.dists.logistic.median( 4.0, 2.0 )\ny = base.dists.logistic.median( NaN, 1.0 )\ny = base.dists.logistic.median( 0.0, NaN )\ny = base.dists.logistic.median( 0.0, 0.0 )\n"
+base.dists.logistic.mgf,"var y = base.dists.logistic.mgf( 0.9, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.1, 4.0, 4.0 )\ny = base.dists.logistic.mgf( -0.2, 4.0, 4.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, -1.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, 4.0 )\ny = base.dists.logistic.mgf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.mgf( 0.0, 0.0, NaN )\n"
+base.dists.logistic.mode,"var y = base.dists.logistic.mode( 0.0, 1.0 )\ny = base.dists.logistic.mode( 4.0, 2.0 )\ny = base.dists.logistic.mode( NaN, 1.0 )\ny = base.dists.logistic.mode( 0.0, NaN )\ny = base.dists.logistic.mode( 0.0, 0.0 )\n"
+base.dists.logistic.pdf,"var y = base.dists.logistic.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.pdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.pdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.logistic.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.pdf( 8.0, 8.0, 0.0 )\n"
+base.dists.logistic.quantile,"var y = base.dists.logistic.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.logistic.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.logistic.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.logistic.quantile( NaN, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.0, NaN, 1.0 )\ny = base.dists.logistic.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.quantile( 0.5, 0.0, -1.0 )\n"
+base.dists.logistic.skewness,"var y = base.dists.logistic.skewness( 0.0, 1.0 )\ny = base.dists.logistic.skewness( 4.0, 2.0 )\ny = base.dists.logistic.skewness( NaN, 1.0 )\ny = base.dists.logistic.skewness( 0.0, NaN )\ny = base.dists.logistic.skewness( 0.0, 0.0 )\n"
+base.dists.logistic.stdev,"var y = base.dists.logistic.stdev( 0.0, 1.0 )\ny = base.dists.logistic.stdev( 4.0, 2.0 )\ny = base.dists.logistic.stdev( NaN, 1.0 )\ny = base.dists.logistic.stdev( 0.0, NaN )\ny = base.dists.logistic.stdev( 0.0, 0.0 )\n"
+base.dists.logistic.variance,"var y = base.dists.logistic.variance( 0.0, 1.0 )\ny = base.dists.logistic.variance( 4.0, 2.0 )\ny = base.dists.logistic.variance( NaN, 1.0 )\ny = base.dists.logistic.variance( 0.0, NaN )\ny = base.dists.logistic.variance( 0.0, 0.0 )\n"
+base.dists.lognormal.cdf,"var y = base.dists.lognormal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, NaN )\ny = base.dists.lognormal.cdf( 2.0, NaN, 1.0 )\ny = base.dists.lognormal.cdf( NaN, 0.0, 1.0 )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.cdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, 0.0 )\n"
+base.dists.lognormal.entropy,"var y = base.dists.lognormal.entropy( 0.0, 1.0 )\ny = base.dists.lognormal.entropy( 5.0, 2.0 )\ny = base.dists.lognormal.entropy( NaN, 1.0 )\ny = base.dists.lognormal.entropy( 0.0, NaN )\ny = base.dists.lognormal.entropy( 0.0, 0.0 )\n"
+base.dists.lognormal.kurtosis,"var y = base.dists.lognormal.kurtosis( 0.0, 1.0 )\ny = base.dists.lognormal.kurtosis( 5.0, 2.0 )\ny = base.dists.lognormal.kurtosis( NaN, 1.0 )\ny = base.dists.lognormal.kurtosis( 0.0, NaN )\ny = base.dists.lognormal.kurtosis( 0.0, 0.0 )\n"
+base.dists.lognormal.LogNormal,"var lognormal = base.dists.lognormal.LogNormal( -2.0, 3.0 );\nlognormal.mu\nlognormal.sigma\nlognormal.entropy\nlognormal.kurtosis\nlognormal.mean\nlognormal.median\nlognormal.mode\nlognormal.skewness\nlognormal.stdev\nlognormal.variance\nlognormal.cdf( 0.8 )\nlognormal.logpdf( 2.0 )\nlognormal.pdf( 2.0 )\nlognormal.quantile( 0.9 )\n"
+base.dists.lognormal.logpdf,"var y = base.dists.lognormal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.logpdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.logpdf( 2.0, 0.0, 0.0 )\n"
+base.dists.lognormal.mean,"var y = base.dists.lognormal.mean( 0.0, 1.0 )\ny = base.dists.lognormal.mean( 4.0, 2.0 )\ny = base.dists.lognormal.mean( NaN, 1.0 )\ny = base.dists.lognormal.mean( 0.0, NaN )\ny = base.dists.lognormal.mean( 0.0, 0.0 )\n"
+base.dists.lognormal.median,"var y = base.dists.lognormal.median( 0.0, 1.0 )\ny = base.dists.lognormal.median( 5.0, 2.0 )\ny = base.dists.lognormal.median( NaN, 1.0 )\ny = base.dists.lognormal.median( 0.0, NaN )\ny = base.dists.lognormal.median( 0.0, 0.0 )\n"
+base.dists.lognormal.mode,"var y = base.dists.lognormal.mode( 0.0, 1.0 )\ny = base.dists.lognormal.mode( 5.0, 2.0 )\ny = base.dists.lognormal.mode( NaN, 1.0 )\ny = base.dists.lognormal.mode( 0.0, NaN )\ny = base.dists.lognormal.mode( 0.0, 0.0 )\n"
+base.dists.lognormal.pdf,"var y = base.dists.lognormal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.pdf( 2.0, 0.0, 0.0 )\n"
+base.dists.lognormal.quantile,"var y = base.dists.lognormal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.lognormal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.quantile( 0.5, 0.0, -1.0 )\ny = base.dists.lognormal.quantile( 0.5, 0.0, 0.0 )\n"
+base.dists.lognormal.skewness,"var y = base.dists.lognormal.skewness( 0.0, 1.0 )\ny = base.dists.lognormal.skewness( 5.0, 2.0 )\ny = base.dists.lognormal.skewness( NaN, 1.0 )\ny = base.dists.lognormal.skewness( 0.0, NaN )\ny = base.dists.lognormal.skewness( 0.0, 0.0 )\n"
+base.dists.lognormal.stdev,"var y = base.dists.lognormal.stdev( 0.0, 1.0 )\ny = base.dists.lognormal.stdev( 4.0, 2.0 )\ny = base.dists.lognormal.stdev( NaN, 1.0 )\ny = base.dists.lognormal.stdev( 0.0, NaN )\ny = base.dists.lognormal.stdev( 0.0, 0.0 )\n"
+base.dists.lognormal.variance,"var y = base.dists.lognormal.variance( 0.0, 1.0 )\ny = base.dists.lognormal.variance( 4.0, 2.0 )\ny = base.dists.lognormal.variance( NaN, 1.0 )\ny = base.dists.lognormal.variance( 0.0, NaN )\ny = base.dists.lognormal.variance( 0.0, 0.0 )\n"
+base.dists.negativeBinomial.cdf,"var y = base.dists.negativeBinomial.cdf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.cdf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.cdf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.cdf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.cdf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, 1.5 )\n"
+base.dists.negativeBinomial.kurtosis,"var v = base.dists.negativeBinomial.kurtosis( 100, 0.2 )\nv = base.dists.negativeBinomial.kurtosis( 20, 0.5 )\n"
+base.dists.negativeBinomial.logpmf,"var y = base.dists.negativeBinomial.logpmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.logpmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 20.0, NaN )\n"
+base.dists.negativeBinomial.mean,"var v = base.dists.negativeBinomial.mean( 100, 0.2 )\nv = base.dists.negativeBinomial.mean( 20, 0.5 )\n"
+base.dists.negativeBinomial.mgf,"var y = base.dists.negativeBinomial.mgf( 0.05, 20.0, 0.8 )\ny = base.dists.negativeBinomial.mgf( 0.1, 20.0, 0.1 )\ny = base.dists.negativeBinomial.mgf( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.mgf( 0.1, 0.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.1, -2.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, -1.0 )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, 1.5 )\n"
+base.dists.negativeBinomial.mode,"var v = base.dists.negativeBinomial.mode( 100, 0.2 )\nv = base.dists.negativeBinomial.mode( 20, 0.5 )\n"
+base.dists.negativeBinomial.NegativeBinomial,"var nbinomial = base.dists.negativeBinomial.NegativeBinomial( 8.0, 0.5 );\nnbinomial.r\nnbinomial.p\nnbinomial.kurtosis\nnbinomial.mean\nnbinomial.mode\nnbinomial.skewness\nnbinomial.stdev\nnbinomial.variance\nnbinomial.cdf( 2.9 )\nnbinomial.logpmf( 3.0 )\nnbinomial.mgf( 0.2 )\nnbinomial.pmf( 3.0 )\nnbinomial.quantile( 0.8 )\n"
+base.dists.negativeBinomial.pmf,"var y = base.dists.negativeBinomial.pmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.pmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.pmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.pmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.pmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.pmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, 20.0, NaN )\n"
+base.dists.negativeBinomial.quantile,"var y = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.2 )\ny = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.8 )\ny = base.dists.negativeBinomial.quantile( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.quantile( 1.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( -0.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.quantile( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.5, 0.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, -1.0 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, 1.5 )\ny = base.dists.negativeBinomial.quantile( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, NaN, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, NaN )\n"
+base.dists.negativeBinomial.skewness,"var v = base.dists.negativeBinomial.skewness( 100, 0.2 )\nv = base.dists.negativeBinomial.skewness( 20, 0.5 )\n"
+base.dists.negativeBinomial.stdev,"var v = base.dists.negativeBinomial.stdev( 100, 0.2 )\nv = base.dists.negativeBinomial.stdev( 20, 0.5 )\n"
+base.dists.negativeBinomial.variance,"var v = base.dists.negativeBinomial.variance( 100, 0.2 )\nv = base.dists.negativeBinomial.variance( 20, 0.5 )\n"
+base.dists.normal.cdf,"var y = base.dists.normal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.cdf( -1.0, -1.0, 2.0 )\ny = base.dists.normal.cdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.cdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.cdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.cdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.cdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 10.0, 8.0, 0.0 )\n"
+base.dists.normal.entropy,"var y = base.dists.normal.entropy( 0.0, 1.0 )\ny = base.dists.normal.entropy( 4.0, 3.0 )\ny = base.dists.normal.entropy( NaN, 1.0 )\ny = base.dists.normal.entropy( 0.0, NaN )\ny = base.dists.normal.entropy( 0.0, 0.0 )\n"
+base.dists.normal.kurtosis,"var y = base.dists.normal.kurtosis( 0.0, 1.0 )\ny = base.dists.normal.kurtosis( 4.0, 3.0 )\ny = base.dists.normal.kurtosis( NaN, 1.0 )\ny = base.dists.normal.kurtosis( 0.0, NaN )\ny = base.dists.normal.kurtosis( 0.0, 0.0 )\n"
+base.dists.normal.logpdf,"var y = base.dists.normal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.logpdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.logpdf( 8.0, 8.0, 0.0 )\n"
+base.dists.normal.mean,"var y = base.dists.normal.mean( 0.0, 1.0 )\ny = base.dists.normal.mean( 4.0, 2.0 )\ny = base.dists.normal.mean( NaN, 1.0 )\ny = base.dists.normal.mean( 0.0, NaN )\ny = base.dists.normal.mean( 0.0, 0.0 )\n"
+base.dists.normal.median,"var y = base.dists.normal.median( 0.0, 1.0 )\ny = base.dists.normal.median( 4.0, 2.0 )\ny = base.dists.normal.median( NaN, 1.0 )\ny = base.dists.normal.median( 0.0, NaN )\ny = base.dists.normal.median( 0.0, 0.0 )\n"
+base.dists.normal.mgf,"var y = base.dists.normal.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.mgf( NaN, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, NaN, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, NaN )\ny = base.dists.normal.mgf( 2.0, 0.0, 0.0 )\n"
+base.dists.normal.mode,"var y = base.dists.normal.mode( 0.0, 1.0 )\ny = base.dists.normal.mode( 4.0, 2.0 )\ny = base.dists.normal.mode( NaN, 1.0 )\ny = base.dists.normal.mode( 0.0, NaN )\ny = base.dists.normal.mode( 0.0, 0.0 )\n"
+base.dists.normal.Normal,"var normal = base.dists.normal.Normal( -2.0, 3.0 );\nnormal.mu\nnormal.sigma\nnormal.entropy\nnormal.kurtosis\nnormal.mean\nnormal.median\nnormal.mode\nnormal.skewness\nnormal.stdev\nnormal.variance\nnormal.cdf( 0.8 )\nnormal.logpdf( 2.0 )\nnormal.mgf( 0.2 )\nnormal.pdf( 2.0 )\nnormal.quantile( 0.9 )\n"
+base.dists.normal.pdf,"var y = base.dists.normal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.pdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.pdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.pdf( 8.0, 8.0, 0.0 )\n"
+base.dists.normal.quantile,"var y = base.dists.normal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.normal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.normal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.normal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.normal.quantile( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.quantile( 0.5, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.quantile( 0.3, 8.0, 0.0 )\ny = base.dists.normal.quantile( 0.9, 8.0, 0.0 )\n"
+base.dists.normal.skewness,"var y = base.dists.normal.skewness( 0.0, 1.0 )\ny = base.dists.normal.skewness( 4.0, 3.0 )\ny = base.dists.normal.skewness( NaN, 1.0 )\ny = base.dists.normal.skewness( 0.0, NaN )\ny = base.dists.normal.skewness( 0.0, 0.0 )\n"
+base.dists.normal.stdev,"var y = base.dists.normal.stdev( 0.0, 1.0 )\ny = base.dists.normal.stdev( 4.0, 3.0 )\ny = base.dists.normal.stdev( NaN, 1.0 )\ny = base.dists.normal.stdev( 0.0, NaN )\ny = base.dists.normal.stdev( 0.0, 0.0 )\n"
+base.dists.normal.variance,"var y = base.dists.normal.variance( 0.0, 1.0 )\ny = base.dists.normal.variance( 4.0, 3.0 )\ny = base.dists.normal.variance( NaN, 1.0 )\ny = base.dists.normal.variance( 0.0, NaN )\ny = base.dists.normal.variance( 0.0, 0.0 )\n"
+base.dists.pareto1.cdf,"var y = base.dists.pareto1.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.cdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.cdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, 1.0, NaN )\n"
+base.dists.pareto1.entropy,"var v = base.dists.pareto1.entropy( 0.8, 1.0 )\nv = base.dists.pareto1.entropy( 4.0, 12.0 )\nv = base.dists.pareto1.entropy( 8.0, 2.0 )\n"
+base.dists.pareto1.kurtosis,"var v = base.dists.pareto1.kurtosis( 5.0, 1.0 )\nv = base.dists.pareto1.kurtosis( 4.5, 12.0 )\nv = base.dists.pareto1.kurtosis( 8.0, 2.0 )\n"
+base.dists.pareto1.logcdf,"var y = base.dists.pareto1.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.logcdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, 1.0, NaN )\n"
+base.dists.pareto1.logpdf,"var y = base.dists.pareto1.logpdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.logpdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.logpdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.logpdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, 1.0, NaN )\n"
+base.dists.pareto1.mean,"var v = base.dists.pareto1.mean( 0.8, 1.0 )\nv = base.dists.pareto1.mean( 4.0, 12.0 )\nv = base.dists.pareto1.mean( 8.0, 2.0 )\n"
+base.dists.pareto1.median,"var v = base.dists.pareto1.median( 0.8, 1.0 )\nv = base.dists.pareto1.median( 4.0, 12.0 )\nv = base.dists.pareto1.median( 8.0, 2.0 )\n"
+base.dists.pareto1.mode,"var v = base.dists.pareto1.mode( 0.8, 1.0 )\nv = base.dists.pareto1.mode( 4.0, 12.0 )\nv = base.dists.pareto1.mode( 8.0, 2.0 )\n"
+base.dists.pareto1.Pareto1,"var pareto1 = base.dists.pareto1.Pareto1( 6.0, 5.0 );\npareto1.alpha\npareto1.beta\npareto1.entropy\npareto1.kurtosis\npareto1.mean\npareto1.median\npareto1.mode\npareto1.skewness\npareto1.variance\npareto1.cdf( 7.0 )\npareto1.logcdf( 7.0 )\npareto1.logpdf( 5.0 )\npareto1.pdf( 5.0 )\npareto1.quantile( 0.8 )\n"
+base.dists.pareto1.pdf,"var y = base.dists.pareto1.pdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.pdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.pdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.pdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.pdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, 1.0, NaN )\n"
+base.dists.pareto1.quantile,"var y = base.dists.pareto1.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.8, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 0.1, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, NaN )\ny = base.dists.pareto1.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.pareto1.skewness,"var v = base.dists.pareto1.skewness( 3.5, 1.0 )\nv = base.dists.pareto1.skewness( 4.0, 12.0 )\nv = base.dists.pareto1.skewness( 8.0, 2.0 )\n"
+base.dists.pareto1.variance,"var v = base.dists.pareto1.variance( 0.8, 1.0 )\nv = base.dists.pareto1.variance( 4.0, 12.0 )\nv = base.dists.pareto1.variance( 8.0, 2.0 )\n"
+base.dists.poisson.cdf,"var y = base.dists.poisson.cdf( 2.0, 0.5 )\ny = base.dists.poisson.cdf( 2.0, 10.0 )\ny = base.dists.poisson.cdf( -1.0, 4.0 )\ny = base.dists.poisson.cdf( NaN, 1.0 )\ny = base.dists.poisson.cdf( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.cdf( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.cdf( -2.0, 0.0 )\ny = base.dists.poisson.cdf( 0.0, 0.0 )\ny = base.dists.poisson.cdf( 10.0, 0.0 )\n"
+base.dists.poisson.entropy,"var v = base.dists.poisson.entropy( 11.0 )\nv = base.dists.poisson.entropy( 4.5 )\n"
+base.dists.poisson.kurtosis,"var v = base.dists.poisson.kurtosis( 11.0 )\nv = base.dists.poisson.kurtosis( 4.5 )\n"
+base.dists.poisson.logpmf,"var y = base.dists.poisson.logpmf( 4.0, 3.0 )\ny = base.dists.poisson.logpmf( 1.0, 3.0 )\ny = base.dists.poisson.logpmf( -1.0, 2.0 )\ny = base.dists.poisson.logpmf( 0.0, NaN )\ny = base.dists.poisson.logpmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.logpmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.logpmf( 2.0, 0.0 )\ny = base.dists.poisson.logpmf( 0.0, 0.0 )\n"
+base.dists.poisson.mean,"var v = base.dists.poisson.mean( 11.0 )\nv = base.dists.poisson.mean( 4.5 )\n"
+base.dists.poisson.median,"var v = base.dists.poisson.median( 11.0 )\nv = base.dists.poisson.median( 4.5 )\n"
+base.dists.poisson.mode,"var v = base.dists.poisson.mode( 11.0 )\nv = base.dists.poisson.mode( 4.5 )\n"
+base.dists.poisson.pmf,"var y = base.dists.poisson.pmf( 4.0, 3.0 )\ny = base.dists.poisson.pmf( 1.0, 3.0 )\ny = base.dists.poisson.pmf( -1.0, 2.0 )\ny = base.dists.poisson.pmf( 0.0, NaN )\ny = base.dists.poisson.pmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.pmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.pmf( 2.0, 0.0 )\ny = base.dists.poisson.pmf( 0.0, 0.0 )\n"
+base.dists.poisson.Poisson,"var poisson = base.dists.poisson.Poisson( 6.0 );\npoisson.lambda\npoisson.entropy\npoisson.kurtosis\npoisson.mean\npoisson.median\npoisson.mode\npoisson.skewness\npoisson.stdev\npoisson.variance\npoisson.cdf( 4.0 )\npoisson.logpmf( 2.0 )\npoisson.mgf( 0.5 )\npoisson.pmf( 2.0 )\npoisson.quantile( 0.5 )\n"
+base.dists.poisson.quantile,"var y = base.dists.poisson.quantile( 0.5, 2.0 )\ny = base.dists.poisson.quantile( 0.9, 4.0 )\ny = base.dists.poisson.quantile( 0.1, 200.0 )\ny = base.dists.poisson.quantile( 1.1, 0.0 )\ny = base.dists.poisson.quantile( -0.2, 0.0 )\ny = base.dists.poisson.quantile( NaN, 0.5 )\ny = base.dists.poisson.quantile( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.quantile( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.quantile( 0.1, 0.0 )\ny = base.dists.poisson.quantile( 0.9, 0.0 )\n"
+base.dists.poisson.skewness,"var v = base.dists.poisson.skewness( 11.0 )\nv = base.dists.poisson.skewness( 4.5 )\n"
+base.dists.poisson.stdev,"var v = base.dists.poisson.stdev( 11.0 )\nv = base.dists.poisson.stdev( 4.5 )\n"
+base.dists.poisson.variance,"var v = base.dists.poisson.variance( 11.0 )\nv = base.dists.poisson.variance( 4.5 )\n"
+base.dists.rayleigh.cdf,"var y = base.dists.rayleigh.cdf( 2.0, 3.0 )\ny = base.dists.rayleigh.cdf( 1.0, 2.0 )\ny = base.dists.rayleigh.cdf( -1.0, 4.0 )\ny = base.dists.rayleigh.cdf( NaN, 1.0 )\ny = base.dists.rayleigh.cdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.cdf( -2.0, 0.0 )\ny = base.dists.rayleigh.cdf( 0.0, 0.0 )\ny = base.dists.rayleigh.cdf( 2.0, 0.0 )\n"
+base.dists.rayleigh.entropy,"var v = base.dists.rayleigh.entropy( 11.0 )\nv = base.dists.rayleigh.entropy( 4.5 )\n"
+base.dists.rayleigh.kurtosis,"var v = base.dists.rayleigh.kurtosis( 11.0 )\nv = base.dists.rayleigh.kurtosis( 4.5 )\n"
+base.dists.rayleigh.logcdf,"var y = base.dists.rayleigh.logcdf( 2.0, 3.0 )\ny = base.dists.rayleigh.logcdf( 1.0, 2.0 )\ny = base.dists.rayleigh.logcdf( -1.0, 4.0 )\ny = base.dists.rayleigh.logcdf( NaN, 1.0 )\ny = base.dists.rayleigh.logcdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logcdf( 2.0, -1.0 )\n"
+base.dists.rayleigh.logpdf,"var y = base.dists.rayleigh.logpdf( 0.3, 1.0 )\ny = base.dists.rayleigh.logpdf( 2.0, 0.8 )\ny = base.dists.rayleigh.logpdf( -1.0, 0.5 )\ny = base.dists.rayleigh.logpdf( 0.0, NaN )\ny = base.dists.rayleigh.logpdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logpdf( 2.0, -1.0 )\n"
+base.dists.rayleigh.mean,"var v = base.dists.rayleigh.mean( 11.0 )\nv = base.dists.rayleigh.mean( 4.5 )\n"
+base.dists.rayleigh.median,"var v = base.dists.rayleigh.median( 11.0 )\nv = base.dists.rayleigh.median( 4.5 )\n"
+base.dists.rayleigh.mgf,"var y = base.dists.rayleigh.mgf( 1.0, 3.0 )\ny = base.dists.rayleigh.mgf( 1.0, 2.0 )\ny = base.dists.rayleigh.mgf( -1.0, 4.0 )\ny = base.dists.rayleigh.mgf( NaN, 1.0 )\ny = base.dists.rayleigh.mgf( 0.0, NaN )\ny = base.dists.rayleigh.mgf( 0.5, -1.0 )\n"
+base.dists.rayleigh.mode,"var v = base.dists.rayleigh.mode( 11.0 )\nv = base.dists.rayleigh.mode( 4.5 )\n"
+base.dists.rayleigh.pdf,"var y = base.dists.rayleigh.pdf( 0.3, 1.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.8 )\ny = base.dists.rayleigh.pdf( -1.0, 0.5 )\ny = base.dists.rayleigh.pdf( 0.0, NaN )\ny = base.dists.rayleigh.pdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.pdf( -2.0, 0.0 )\ny = base.dists.rayleigh.pdf( 0.0, 0.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.0 )\n"
+base.dists.rayleigh.quantile,"var y = base.dists.rayleigh.quantile( 0.8, 1.0 )\ny = base.dists.rayleigh.quantile( 0.5, 4.0 )\ny = base.dists.rayleigh.quantile( 1.1, 1.0 )\ny = base.dists.rayleigh.quantile( -0.2, 1.0 )\ny = base.dists.rayleigh.quantile( NaN, 1.0 )\ny = base.dists.rayleigh.quantile( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.quantile( 0.5, -1.0 )\n"
+base.dists.rayleigh.Rayleigh,"var rayleigh = base.dists.rayleigh.Rayleigh( 6.0 );\nrayleigh.sigma\nrayleigh.entropy\nrayleigh.kurtosis\nrayleigh.mean\nrayleigh.median\nrayleigh.mode\nrayleigh.skewness\nrayleigh.stdev\nrayleigh.variance\nrayleigh.cdf( 1.0 )\nrayleigh.logcdf( 1.0 )\nrayleigh.logpdf( 1.5 )\nrayleigh.mgf( -0.5 )\nrayleigh.pdf( 1.5 )\nrayleigh.quantile( 0.5 )\n"
+base.dists.rayleigh.skewness,"var v = base.dists.rayleigh.skewness( 11.0 )\nv = base.dists.rayleigh.skewness( 4.5 )\n"
+base.dists.rayleigh.stdev,"var v = base.dists.rayleigh.stdev( 9.0 )\nv = base.dists.rayleigh.stdev( 4.5 )\n"
+base.dists.rayleigh.variance,"var v = base.dists.rayleigh.variance( 9.0 )\nv = base.dists.rayleigh.variance( 4.5 )\n"
+base.dists.t.cdf,"var y = base.dists.t.cdf( 2.0, 0.1 )\ny = base.dists.t.cdf( 1.0, 2.0 )\ny = base.dists.t.cdf( -1.0, 4.0 )\ny = base.dists.t.cdf( NaN, 1.0 )\ny = base.dists.t.cdf( 0.0, NaN )\ny = base.dists.t.cdf( 2.0, -1.0 )\n"
+base.dists.t.entropy,"var v = base.dists.t.entropy( 11.0 )\nv = base.dists.t.entropy( 4.5 )\n"
+base.dists.t.kurtosis,"var v = base.dists.t.kurtosis( 11.0 )\nv = base.dists.t.kurtosis( 4.5 )\n"
+base.dists.t.mean,"var v = base.dists.t.mean( 11.0 )\nv = base.dists.t.mean( 4.5 )\n"
+base.dists.t.median,"var v = base.dists.t.median( 11.0 )\nv = base.dists.t.median( 4.5 )\n"
+base.dists.t.mode,"var v = base.dists.t.mode( 11.0 )\nv = base.dists.t.mode( 4.5 )\n"
+base.dists.t.pdf,"var y = base.dists.t.pdf( 0.3, 4.0 )\ny = base.dists.t.pdf( 2.0, 0.7 )\ny = base.dists.t.pdf( -1.0, 0.5 )\ny = base.dists.t.pdf( 0.0, NaN )\ny = base.dists.t.pdf( NaN, 2.0 )\ny = base.dists.t.pdf( 2.0, -1.0 )\n"
+base.dists.t.quantile,"var y = base.dists.t.quantile( 0.8, 1.0 )\ny = base.dists.t.quantile( 0.1, 1.0 )\ny = base.dists.t.quantile( 0.5, 0.1 )\ny = base.dists.t.quantile( -0.2, 0.1 )\ny = base.dists.t.quantile( NaN, 1.0 )\ny = base.dists.t.quantile( 0.0, NaN )\ny = base.dists.t.quantile( 0.5, -1.0 )\n"
+base.dists.t.skewness,"var v = base.dists.t.skewness( 11.0 )\nv = base.dists.t.skewness( 4.5 )\n"
+base.dists.t.stdev,"var v = base.dists.t.stdev( 9.0 )\nv = base.dists.t.stdev( 4.5 )\n"
+base.dists.t.T,"var t = base.dists.t.T( 6.0 );\nt.v\nt.entropy\nt.kurtosis\nt.mean\nt.median\nt.mode\nt.skewness\nt.stdev\nt.variance\nt.cdf( 1.0 )\nt.logcdf( 1.0 )\nt.logpdf( 1.5 )\nt.pdf( 1.5 )\nt.quantile( 0.8 )\n"
+base.dists.t.variance,"var v = base.dists.t.variance( 9.0 )\nv = base.dists.t.variance( 4.5 )\n"
+base.dists.triangular.cdf,"var y = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.cdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.entropy,"var v = base.dists.triangular.entropy( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.entropy( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.entropy( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.kurtosis,"var v = base.dists.triangular.kurtosis( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.kurtosis( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.kurtosis( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.logcdf,"var y = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logcdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.logpdf,"var y = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logpdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.mean,"var v = base.dists.triangular.mean( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mean( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mean( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.median,"var v = base.dists.triangular.median( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.median( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.median( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.mgf,"var y = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( -0.3, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.mgf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, NaN )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.mode,"var v = base.dists.triangular.mode( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mode( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mode( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.pdf,"var y = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.pdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.quantile,"var y = base.dists.triangular.quantile( 0.9, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( 0.1, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.1, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.quantile( 0.8, 0.0, 20.0, 0.0 )\ny = base.dists.triangular.quantile( 1.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( -0.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, NaN, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 0.0, NaN, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, NaN )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, 1.5 )\n"
+base.dists.triangular.skewness,"var v = base.dists.triangular.skewness( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.skewness( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.skewness( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.stdev,"var v = base.dists.triangular.stdev( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.stdev( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.stdev( 2.0, 8.0, 5.0 )\n"
+base.dists.triangular.Triangular,"var triangular = base.dists.triangular.Triangular( 0.0, 1.0, 0.5 );\ntriangular.a\ntriangular.b\ntriangular.c\ntriangular.entropy\ntriangular.kurtosis\ntriangular.mean\ntriangular.median\ntriangular.mode\ntriangular.skewness\ntriangular.stdev\ntriangular.variance\ntriangular.cdf( 0.8 )\ntriangular.logcdf( 0.8 )\ntriangular.logpdf( 0.8 )\ntriangular.mgf( 0.8 )\ntriangular.pdf( 0.8 )\ntriangular.quantile( 0.8 )\n"
+base.dists.triangular.variance,"var v = base.dists.triangular.variance( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.variance( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.variance( 2.0, 8.0, 5.0 )\n"
+base.dists.uniform.cdf,"var y = base.dists.uniform.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.cdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.cdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.cdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.cdf( 2.0, 1.0, 0.0 )\n"
+base.dists.uniform.entropy,"var v = base.dists.uniform.entropy( 0.0, 1.0 )\nv = base.dists.uniform.entropy( 4.0, 12.0 )\nv = base.dists.uniform.entropy( 2.0, 8.0 )\n"
+base.dists.uniform.kurtosis,"var v = base.dists.uniform.kurtosis( 0.0, 1.0 )\nv = base.dists.uniform.kurtosis( 4.0, 12.0 )\nv = base.dists.uniform.kurtosis( 2.0, 8.0 )\n"
+base.dists.uniform.logcdf,"var y = base.dists.uniform.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logcdf( 2.0, 1.0, 0.0 )\n"
+base.dists.uniform.logpdf,"var y = base.dists.uniform.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logpdf( 2.0, 3.0, 1.0 )\n"
+base.dists.uniform.mean,"var v = base.dists.uniform.mean( 0.0, 1.0 )\nv = base.dists.uniform.mean( 4.0, 12.0 )\nv = base.dists.uniform.mean( 2.0, 8.0 )\n"
+base.dists.uniform.median,"var v = base.dists.uniform.median( 0.0, 1.0 )\nv = base.dists.uniform.median( 4.0, 12.0 )\nv = base.dists.uniform.median( 2.0, 8.0 )\n"
+base.dists.uniform.mgf,"var y = base.dists.uniform.mgf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.mgf( -0.2, 0.0, 4.0 )\ny = base.dists.uniform.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 2.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 3.0 )\ny = base.dists.uniform.mgf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.mgf( 0.0, 0.0, NaN )\n"
+base.dists.uniform.pdf,"var y = base.dists.uniform.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.pdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.pdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.pdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.pdf( 2.0, 3.0, 1.0 )\n"
+base.dists.uniform.quantile,"var y = base.dists.uniform.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.uniform.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.uniform.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.uniform.quantile( NaN, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.0, NaN, 1.0 )\ny = base.dists.uniform.quantile( 0.0, 0.0, NaN )\ny = base.dists.uniform.quantile( 0.5, 2.0, 1.0 )\n"
+base.dists.uniform.skewness,"var v = base.dists.uniform.skewness( 0.0, 1.0 )\nv = base.dists.uniform.skewness( 4.0, 12.0 )\nv = base.dists.uniform.skewness( 2.0, 8.0 )\n"
+base.dists.uniform.stdev,"var v = base.dists.uniform.stdev( 0.0, 1.0 )\nv = base.dists.uniform.stdev( 4.0, 12.0 )\nv = base.dists.uniform.stdev( 2.0, 8.0 )\n"
+base.dists.uniform.Uniform,"var uniform = base.dists.uniform.Uniform( 0.0, 1.0 );\nuniform.a\nuniform.b\nuniform.entropy\nuniform.kurtosis\nuniform.mean\nuniform.median\nuniform.skewness\nuniform.stdev\nuniform.variance\nuniform.cdf( 0.8 )\nuniform.logcdf( 0.5 )\nuniform.logpdf( 1.0 )\nuniform.mgf( 0.8 )\nuniform.pdf( 0.8 )\nuniform.quantile( 0.8 )\n"
+base.dists.uniform.variance,"var v = base.dists.uniform.variance( 0.0, 1.0 )\nv = base.dists.uniform.variance( 4.0, 12.0 )\nv = base.dists.uniform.variance( 2.0, 8.0 )\n"
+base.dists.weibull.cdf,"var y = base.dists.weibull.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.cdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.cdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.cdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.cdf( 2.0, 0.0, -1.0 )\n"
+base.dists.weibull.entropy,"var v = base.dists.weibull.entropy( 1.0, 1.0 )\nv = base.dists.weibull.entropy( 4.0, 12.0 )\nv = base.dists.weibull.entropy( 8.0, 2.0 )\n"
+base.dists.weibull.kurtosis,"var v = base.dists.weibull.kurtosis( 1.0, 1.0 )\nv = base.dists.weibull.kurtosis( 4.0, 12.0 )\nv = base.dists.weibull.kurtosis( 8.0, 2.0 )\n"
+base.dists.weibull.logcdf,"var y = base.dists.weibull.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.logcdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logcdf( 2.0, 0.0, -1.0 )\n"
+base.dists.weibull.logpdf,"var y = base.dists.weibull.logpdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logpdf( 2.0, 0.0, -1.0 )\n"
+base.dists.weibull.mean,"var v = base.dists.weibull.mean( 1.0, 1.0 )\nv = base.dists.weibull.mean( 4.0, 12.0 )\nv = base.dists.weibull.mean( 8.0, 2.0 )\n"
+base.dists.weibull.median,"var v = base.dists.weibull.median( 1.0, 1.0 )\nv = base.dists.weibull.median( 4.0, 12.0 )\nv = base.dists.weibull.median( 8.0, 2.0 )\n"
+base.dists.weibull.mgf,"var y = base.dists.weibull.mgf( 1.0, 1.0, 0.5 )\ny = base.dists.weibull.mgf( -1.0, 4.0, 4.0 )\ny = base.dists.weibull.mgf( NaN, 1.0, 1.0 )\ny = base.dists.weibull.mgf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.mgf( 0.0, 1.0, NaN )\ny = base.dists.weibull.mgf( 0.2, -1.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.5, -1.0 )\ny = base.dists.weibull.mgf( 0.2, 0.5, 0.0 )\n"
+base.dists.weibull.mode,"var v = base.dists.weibull.mode( 1.0, 1.0 )\nv = base.dists.weibull.mode( 4.0, 12.0 )\nv = base.dists.weibull.mode( 8.0, 2.0 )\n"
+base.dists.weibull.pdf,"var y = base.dists.weibull.pdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.pdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.pdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.pdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.pdf( 2.0, 0.0, -1.0 )\n"
+base.dists.weibull.quantile,"var y = base.dists.weibull.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.weibull.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.weibull.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.weibull.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.weibull.quantile( NaN, 0.0, 1.0 )\ny = base.dists.weibull.quantile( 0.0, NaN, 1.0 )\ny = base.dists.weibull.quantile( 0.0, 0.0, NaN )\ny = base.dists.weibull.quantile( 0.5, 1.0, -1.0 )\n"
+base.dists.weibull.skewness,"var v = base.dists.weibull.skewness( 1.0, 1.0 )\nv = base.dists.weibull.skewness( 4.0, 12.0 )\nv = base.dists.weibull.skewness( 8.0, 2.0 )\n"
+base.dists.weibull.stdev,"var v = base.dists.weibull.stdev( 1.0, 1.0 )\nv = base.dists.weibull.stdev( 4.0, 12.0 )\nv = base.dists.weibull.stdev( 8.0, 2.0 )\n"
+base.dists.weibull.variance,"var v = base.dists.weibull.variance( 1.0, 1.0 )\nv = base.dists.weibull.variance( 4.0, 12.0 )\nv = base.dists.weibull.variance( 8.0, 2.0 )\n"
+base.dists.weibull.Weibull,"var weibull = base.dists.weibull.Weibull( 6.0, 5.0 );\nweibull.k\nweibull.lambda\nweibull.entropy\nweibull.kurtosis\nweibull.mean\nweibull.median\nweibull.mode\nweibull.skewness\nweibull.stdev\nweibull.variance\nweibull.cdf( 3.0 )\nweibull.logcdf( 3.0 )\nweibull.logpdf( 1.0 )\nweibull.mgf( -0.5 )\nweibull.pdf( 3.0 )\nweibull.quantile( 0.8 )\n"
+base.ellipe,"var y = base.ellipe( 0.5 )\ny = base.ellipe( -1.0 )\ny = base.ellipe( 2.0 )\ny = base.ellipe( PINF )\ny = base.ellipe( NINF )\ny = base.ellipe( NaN )\n"
+base.ellipk,"var y = base.ellipk( 0.5 )\ny = base.ellipk( -1.0 )\ny = base.ellipk( 2.0 )\ny = base.ellipk( PINF )\ny = base.ellipk( NINF )\ny = base.ellipk( NaN )\n"
+base.epsdiff,"var d = base.epsdiff( 12.15, 12.149999999999999 )\nd = base.epsdiff( 2.4341309458983933, 2.4341309458633909, 'mean-abs' )\n\n// Custom scale function:\nfunction scale( x, y ) { return ( x > y ) ? y : x; };\nd = base.epsdiff( 1.0000000000000002, 1.0000000000000100, scale )\n"
+base.erf,"var y = base.erf( 2.0 )\ny = base.erf( -1.0 )\ny = base.erf( -0.0 )\ny = base.erf( NaN )\n"
+base.erfc,"var y = base.erfc( 2.0 )\ny = base.erfc( -1.0 )\ny = base.erfc( 0.0 )\ny = base.erfc( PINF )\ny = base.erfc( NINF )\ny = base.erfc( NaN )\n"
+base.erfcinv,"var y = base.erfcinv( 0.5 )\ny = base.erfcinv( 0.8 )\ny = base.erfcinv( 0.0 )\ny = base.erfcinv( 2.0 )\ny = base.erfcinv( NaN )\n"
+base.erfinv,"var y = base.erfinv( 0.5 )\ny = base.erfinv( 0.8 )\ny = base.erfinv( 0.0 )\ny = base.erfinv( -0.0 )\ny = base.erfinv( -1.0 )\ny = base.erfinv( 1.0 )\ny = base.erfinv( NaN )\n"
+base.eta,"var y = base.eta( 0.0 )\ny = base.eta( -1.0 )\ny = base.eta( 1.0 )\ny = base.eta( 3.14 )\ny = base.eta( NaN )\n"
+base.evalpoly,"var arr = [ 3.0, 2.0, 1.0 ];\n\n// 3*10^0 + 2*10^1 + 1*10^2\nvar v = base.evalpoly( arr, 10.0 )\n"
+base.evalrational,"\n// 2x^3 + 4x^2 - 5x^1 - 6x^0\nvar P = [ -6.0, -5.0, 4.0, 2.0 ];\n\n// 0.5x^1 + 3x^0\nvar Q = [ 3.0, 0.5, 0.0, 0.0 ]; // zero-padded\n\n// Evaluate the rational function:\nvar v = base.evalrational( P, Q, 6.0 )\n"
+base.exp,"var y = base.exp( 4.0 )\ny = base.exp( -9.0 )\ny = base.exp( 0.0 )\ny = base.exp( NaN )\n"
+base.exp2,"var y = base.exp2( 3.0 )\ny = base.exp2( -9.0 )\ny = base.exp2( 0.0 )\ny = base.exp2( NaN )\n"
+base.exp10,"var y = base.exp10( 3.0 )\ny = base.exp10( -9.0 )\ny = base.exp10( 0.0 )\ny = base.exp10( NaN )\n"
+base.expit,"var y = base.expit( 0.0 )\ny = base.expit( 1.0 )\ny = base.expit( -1.0 )\ny = base.expit( Infinity )\ny = base.expit( NaN )\n"
+base.expm1,"var y = base.expm1( 0.2 )\ny = base.expm1( -9.0 )\ny = base.expm1( 0.0 )\ny = base.expm1( NaN )\n"
+base.expm1rel,"var y = base.expm1rel( 0.0 )\ny = base.expm1rel( 1.0 )\ny = base.expm1rel( -1.0 )\ny = base.expm1rel( NaN )\n"
+base.exponent,"var exponent = base.exponent( 3.14e-307 )\nexponent = base.exponent( -3.14 )\nexponent = base.exponent( 0.0 )\nexponent = base.exponent( NaN )\n"
+base.exponentf,"var exponent = base.exponentf( base.float64ToFloat32( 3.14e34 ) )\nexponent = base.exponentf( base.float64ToFloat32( 3.14e-34 ) )\nexponent = base.exponentf( base.float64ToFloat32( -3.14 ) )\nexponent = base.exponentf( 0.0 )\nexponent = base.exponentf( NaN )\n"
+base.factorial,"var y = base.factorial( 3.0 )\ny = base.factorial( -1.5 )\ny = base.factorial( -0.5 )\ny = base.factorial( 0.5 )\ny = base.factorial( -10.0 )\ny = base.factorial( 171.0 )\ny = base.factorial( NaN )\n"
+base.factorialln,"var y = base.factorialln( 3.0 )\ny = base.factorialln( 2.4 )\ny = base.factorialln( -1.0 )\ny = base.factorialln( -1.5 )\ny = base.factorialln( NaN )\n"
+base.fallingFactorial,"var v = base.fallingFactorial( 0.9, 5 )\nv = base.fallingFactorial( -9.0, 3 )\nv = base.fallingFactorial( 0.0, 2 )\nv = base.fallingFactorial( 3.0, -2 )\n"
+base.fibonacci,"var y = base.fibonacci( 0 )\ny = base.fibonacci( 1 )\ny = base.fibonacci( 2 )\ny = base.fibonacci( 3 )\ny = base.fibonacci( 4 )\ny = base.fibonacci( 79 )\ny = base.fibonacci( NaN )\n"
+base.fibonacciIndex,"var n = base.fibonacciIndex( 2 )\nn = base.fibonacciIndex( 3 )\nn = base.fibonacciIndex( 5 )\nn = base.fibonacciIndex( NaN )\nn = base.fibonacciIndex( 1 )\n"
+base.fibpoly,"\n// 2^4 + 3*2^2 + 1\nvar v = base.fibpoly( 5, 2.0 )\n"
+base.flipsign,"var z = base.flipsign( -3.14, 10.0 )\nz = base.flipsign( -3.14, -1.0 )\nz = base.flipsign( 1.0, -0.0 )\nz = base.flipsign( -3.14, -0.0 )\nz = base.flipsign( -0.0, 1.0 )\nz = base.flipsign( 0.0, -1.0 )\n"
+base.float32ToInt32,"var y = base.float32ToInt32( base.float64ToFloat32( 4294967295.0 ) )\ny = base.float32ToInt32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( NaN ) )\ny = base.float32ToInt32( FLOAT32_PINF )\ny = base.float32ToInt32( FLOAT32_NINF )\n"
+base.float32ToUint32,"var y = base.float32ToUint32( base.float64ToFloat32( 4294967297.0 ) )\ny = base.float32ToUint32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( NaN ) )\ny = base.float32ToUint32( FLOAT32_PINF )\ny = base.float32ToUint32( FLOAT32_NINF )\n"
+base.float64ToFloat32,"var y = base.float64ToFloat32( 1.337 )\n"
+base.float64ToInt32,"var y = base.float64ToInt32( 4294967295.0 )\ny = base.float64ToInt32( 3.14 )\ny = base.float64ToInt32( -3.14 )\ny = base.float64ToInt32( NaN )\ny = base.float64ToInt32( PINF )\ny = base.float64ToInt32( NINF )\n"
+base.float64ToUint32,"var y = base.float64ToUint32( 4294967297.0 )\ny = base.float64ToUint32( 3.14 )\ny = base.float64ToUint32( -3.14 )\ny = base.float64ToUint32( NaN )\ny = base.float64ToUint32( PINF )\ny = base.float64ToUint32( NINF )\n"
+base.floor,"var y = base.floor( 3.14 )\ny = base.floor( -4.2 )\ny = base.floor( -4.6 )\ny = base.floor( 9.5 )\ny = base.floor( -0.0 )\n"
+base.floor2,"var y = base.floor2( 3.14 )\ny = base.floor2( -4.2 )\ny = base.floor2( -4.6 )\ny = base.floor2( 9.5 )\ny = base.floor2( 13.0 )\ny = base.floor2( -13.0 )\ny = base.floor2( -0.0 )\n"
+base.floor10,"var y = base.floor10( 3.14 )\ny = base.floor10( -4.2 )\ny = base.floor10( -4.6 )\ny = base.floor10( 9.5 )\ny = base.floor10( 13.0 )\ny = base.floor10( -13.0 )\ny = base.floor10( -0.0 )\n"
+base.floorb,"\n// Round to 4 decimal places:\nvar y = base.floorb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.floorb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward negative infinity:\ny = base.floorb( 5.0, 1, 2 )\n"
+base.floorn,"\n// Round to 4 decimal places:\nvar y = base.floorn( 3.14159, -4 )\n\n// If `n = 0`, standard round toward negative infinity behavior:\ny = base.floorn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.floorn( 12368.0, 3 )\n"
+base.floorsd,"var y = base.floorsd( 3.14159, 5 )\ny = base.floorsd( 3.14159, 1 )\ny = base.floorsd( 12368.0, 2 )\ny = base.floorsd( 0.0313, 2, 2 )\n"
+base.fresnel,"var y = base.fresnel( 0.0 )\ny = base.fresnel( 1.0 )\ny = base.fresnel( PINF )\ny = base.fresnel( NINF )\ny = base.fresnel( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.fresnel( out, 0.0 )\nvar bool = ( v === out )\n"
+base.fresnelc,"var y = base.fresnelc( 0.0 )\ny = base.fresnelc( 1.0 )\ny = base.fresnelc( PINF )\ny = base.fresnelc( NINF )\ny = base.fresnelc( NaN )\n"
+base.fresnels,"var y = base.fresnels( 0.0 )\ny = base.fresnels( 1.0 )\ny = base.fresnels( PINF )\ny = base.fresnels( NINF )\ny = base.fresnels( NaN )\n"
+base.frexp,"var out = base.frexp( 4.0 )\nout = base.frexp( 0.0 )\nout = base.frexp( -0.0 )\nout = base.frexp( NaN )\nout = base.frexp( PINF )\nout = base.frexp( NINF )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar y = base.frexp( out, 4.0 )\nvar bool = ( y === out )\n"
+base.fromBinaryString,"var bstr;\nbstr = '0100000000010000000000000000000000000000000000000000000000000000';\nvar val = base.fromBinaryString( bstr )\nbstr = '0100000000001001001000011111101101010100010001000010110100011000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111100001110011001111001110000101111010111100100010100000';\nval = base.fromBinaryString( bstr )\n\n// The function handles subnormals:\nbstr = '1000000000000000000000000000000000000000000000000001100011010011';\nval = base.fromBinaryString( bstr )\nbstr = '0000000000000000000000000000000000000000000000000000000000000001';\nval = base.fromBinaryString( bstr )\n\n// The function handles special values:\nbstr = '0000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111111000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\n"
+base.fromBinaryStringf,"var bstr = '01000000100000000000000000000000';\nvar val = base.fromBinaryStringf( bstr )\nbstr = '01000000010010010000111111011011';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111011011000011101000110011';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles subnormals:\nbstr = '10000000000000000000000000010110';\nval = base.fromBinaryStringf( bstr )\nbstr = '00000000000000000000000000000001';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles special values:\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '10000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111110000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\n"
+base.fromBinaryStringUint8,"var bstr = '01010101';\nvar val = base.fromBinaryStringUint8( bstr )\nbstr = '00000000';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '00000010';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '11111111';\nval = base.fromBinaryStringUint8( bstr )\n"
+base.fromBinaryStringUint16,"var bstr = '0101010101010101';\nvar val = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000000';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000010';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '1111111111111111';\nval = base.fromBinaryStringUint16( bstr )\n"
+base.fromBinaryStringUint32,"var bstr = '01010101010101010101010101010101';\nvar val = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000010';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '11111111111111111111111111111111';\nval = base.fromBinaryStringUint32( bstr )\n"
+base.fromWordf,"var word = 1068180177; // => 0 01111111 01010110010001011010001\nvar f32 = base.fromWordf( word ) // when printed, promoted to float64\n"
+base.fromWords,"var v = base.fromWords( 1774486211, 2479577218 )\nv = base.fromWords( 3221823995, 1413754136 )\nv = base.fromWords( 0, 0 )\nv = base.fromWords( 2147483648, 0 )\nv = base.fromWords( 2146959360, 0 )\nv = base.fromWords( 2146435072, 0 )\nv = base.fromWords( 4293918720, 0 )\n"
+base.gamma,"var y = base.gamma( 4.0 )\ny = base.gamma( -1.5 )\ny = base.gamma( -0.5 )\ny = base.gamma( 0.5 )\ny = base.gamma( 0.0 )\ny = base.gamma( -0.0 )\ny = base.gamma( NaN )\n"
+base.gamma1pm1,"var y = base.gamma1pm1( 0.2 )\ny = base.gamma1pm1( -6.7 )\ny = base.gamma1pm1( 0.0 )\ny = base.gamma1pm1( NaN )\n"
+base.gammaDeltaRatio,"var y = base.gammaDeltaRatio( 2.0, 3.0 )\ny = base.gammaDeltaRatio( 4.0, 0.5 )\ny = base.gammaDeltaRatio( 100.0, 0.0 )\ny = base.gammaDeltaRatio( NaN, 3.0 )\ny = base.gammaDeltaRatio( 5.0, NaN )\ny = base.gammaDeltaRatio( NaN, NaN )\n"
+base.gammainc,"var y = base.gammainc( 6.0, 2.0 )\ny = base.gammainc( 1.0, 2.0, true, true )\ny = base.gammainc( 7.0, 5.0 )\ny = base.gammainc( 7.0, 5.0, false )\ny = base.gammainc( NaN, 2.0 )\ny = base.gammainc( 6.0, NaN )\n"
+base.gammaincinv,"var y = base.gammaincinv( 0.5, 2.0 )\ny = base.gammaincinv( 0.1, 10.0 )\ny = base.gammaincinv( 0.75, 3.0 )\ny = base.gammaincinv( 0.75, 3.0, true )\ny = base.gammaincinv( 0.75, NaN )\ny = base.gammaincinv( NaN, 3.0 )\n"
+base.gammaLanczosSum,"var y = base.gammaLanczosSum( 4.0 )\ny = base.gammaLanczosSum( -1.5 )\ny = base.gammaLanczosSum( -0.5 )\ny = base.gammaLanczosSum( 0.5 )\ny = base.gammaLanczosSum( 0.0 )\ny = base.gammaLanczosSum( NaN )\n"
+base.gammaLanczosSumExpGScaled,"var y = base.gammaLanczosSumExpGScaled( 4.0 )\ny = base.gammaLanczosSumExpGScaled( -1.5 )\ny = base.gammaLanczosSumExpGScaled( -0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.0 )\ny = base.gammaLanczosSumExpGScaled( NaN )\n"
+base.gammaln,"var y = base.gammaln( 1.0 )\ny = base.gammaln( 2.0 )\ny = base.gammaln( 4.0 )\ny = base.gammaln( -0.5 )\ny = base.gammaln( 0.5 )\ny = base.gammaln( 0.0 )\ny = base.gammaln( NaN )\n"
+base.gasum,"\n// Standard usage:\nvar x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];\nvar sum = base.gasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.gasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.gasum( N, x1, stride )\n"
+base.gaxpy,"\n// Standard usage:\nvar x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar y = [ 1.0, 1.0, 1.0, 1.0, 1.0 ];\nvar alpha = 5.0;\nbase.gaxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\nbase.gaxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gaxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n"
+base.gcd,"var v = base.gcd( 48, 18 )\n"
+base.gcopy,"\n// Standard usage:\nvar x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar y = [ 6.0, 7.0, 8.0, 9.0, 10.0 ];\nbase.gcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\ny = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\nvar N = base.floor( x.length / 2 );\nbase.gcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gcopy( N, x1, -2, y1, 1 )\ny0\n"
+base.getHighWord,"var w = base.getHighWord( 3.14e201 )\n"
+base.getLowWord,"var w = base.getLowWord( 3.14e201 )\n"
+base.hacovercos,"var y = base.hacovercos( 3.14 )\ny = base.hacovercos( -4.2 )\ny = base.hacovercos( -4.6 )\ny = base.hacovercos( 9.5 )\ny = base.hacovercos( -0.0 )\n"
+base.hacoversin,"var y = base.hacoversin( 3.14 )\ny = base.hacoversin( -4.2 )\ny = base.hacoversin( -4.6 )\ny = base.hacoversin( 9.5 )\ny = base.hacoversin( -0.0 )\n"
+base.havercos,"var y = base.havercos( 3.14 )\ny = base.havercos( -4.2 )\ny = base.havercos( -4.6 )\ny = base.havercos( 9.5 )\ny = base.havercos( -0.0 )\n"
+base.haversin,"var y = base.haversin( 3.14 )\ny = base.haversin( -4.2 )\ny = base.haversin( -4.6 )\ny = base.haversin( 9.5 )\ny = base.haversin( -0.0 )\n"
+base.heaviside,"var y = base.heaviside( 3.14 )\ny = base.heaviside( -3.14 )\ny = base.heaviside( 0.0 )\ny = base.heaviside( 0.0, 'half-maximum' )\ny = base.heaviside( 0.0, 'left-continuous' )\ny = base.heaviside( 0.0, 'right-continuous' )\n"
+base.hermitepoly,"var y = base.hermitepoly( 1, 0.5 )\ny = base.hermitepoly( -1, 0.5 )\ny = base.hermitepoly( 0, 0.5 )\ny = base.hermitepoly( 2, 0.5 )\n"
+base.hypot,"var h = base.hypot( -5.0, 12.0 )\nh = base.hypot( NaN, 12.0 )\nh = base.hypot( -0.0, -0.0 )\n"
+base.imul,"var v = base.imul( -10|0, 4|0 )\n"
+base.imuldw,"var v = base.imuldw( 1, 10 )\n"
+base.int32ToUint32,"var y = base.int32ToUint32( base.float64ToInt32( -32 ) )\ny = base.int32ToUint32( base.float64ToInt32( 3 ) )\n"
+base.inv,"var y = base.inv( -1.0 )\ny = base.inv( 2.0 )\ny = base.inv( 0.0 )\ny = base.inv( -0.0 )\ny = base.inv( NaN )\n"
+base.isEven,"var bool = base.isEven( 5.0 )\nbool = base.isEven( -2.0 )\nbool = base.isEven( 0.0 )\nbool = base.isEven( NaN )\n"
+base.isEvenInt32,"var bool = base.isEvenInt32( 5 )\nbool = base.isEvenInt32( -2 )\nbool = base.isEvenInt32( 0 )\n"
+base.isFinite,"var bool = base.isFinite( 5.0 )\nbool = base.isFinite( -2.0e64 )\nbool = base.isFinite( PINF )\nbool = base.isFinite( NINF )\n"
+base.isInfinite,"var bool = base.isInfinite( PINF )\nbool = base.isInfinite( NINF )\nbool = base.isInfinite( 5.0 )\nbool = base.isInfinite( NaN )\n"
+base.isInteger,"var bool = base.isInteger( 1.0 )\nbool = base.isInteger( 3.14 )\n"
+base.isnan,"var bool = base.isnan( NaN )\nbool = base.isnan( 7.0 )\n"
+base.isNegativeInteger,"var bool = base.isNegativeInteger( -1.0 )\nbool = base.isNegativeInteger( 0.0 )\nbool = base.isNegativeInteger( 10.0 )\n"
+base.isNegativeZero,"var bool = base.isNegativeZero( -0.0 )\nbool = base.isNegativeZero( 0.0 )\n"
+base.isNonNegativeInteger,"var bool = base.isNonNegativeInteger( 1.0 )\nbool = base.isNonNegativeInteger( 0.0 )\nbool = base.isNonNegativeInteger( -10.0 )\n"
+base.isNonPositiveInteger,"var bool = base.isNonPositiveInteger( -1.0 )\nbool = base.isNonPositiveInteger( 0.0 )\nbool = base.isNonPositiveInteger( 10.0 )\n"
+base.isOdd,"var bool = base.isOdd( 5.0 )\nbool = base.isOdd( -2.0 )\nbool = base.isOdd( 0.0 )\nbool = base.isOdd( NaN )\n"
+base.isOddInt32,"var bool = base.isOddInt32( 5 )\nbool = base.isOddInt32( -2 )\nbool = base.isOddInt32( 0 )\n"
+base.isPositiveInteger,"var bool = base.isPositiveInteger( 1.0 )\nbool = base.isPositiveInteger( 0.0 )\nbool = base.isPositiveInteger( -10.0 )\n"
+base.isPositiveZero,"var bool = base.isPositiveZero( 0.0 )\nbool = base.isPositiveZero( -0.0 )\n"
+base.isPow2Uint32,"var bool = base.isPow2Uint32( 2 )\nbool = base.isPow2Uint32( 5 )\n"
+base.isProbability,"var bool = base.isProbability( 0.5 )\nbool = base.isProbability( 3.14 )\nbool = base.isProbability( NaN )\n"
+base.isSafeInteger,"var bool = base.isSafeInteger( 1.0 )\nbool = base.isSafeInteger( 2.0e200 )\nbool = base.isSafeInteger( 3.14 )\n"
+base.kernelBetainc,"var out = base.kernelBetainc( 0.8, 1.0, 0.3, false, false )\nout = base.kernelBetainc( 0.2, 1.0, 2.0, true, false )\nout = new Array( 2 );\nvar v = base.kernelBetainc( out, 0.2, 1.0, 2.0, true, true )\nvar bool = ( v === out )\n"
+base.kernelBetaincinv,"var y = base.kernelBetaincinv( 3.0, 3.0, 0.2, 0.8 )\ny = base.kernelBetaincinv( 3.0, 3.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.8, 0.2 )\n"
+base.kernelCos,"var out = base.kernelCos( 0.0, 0.0 )\nout = base.kernelCos( PI/6.0, 0.0 )\nout = base.kernelCos( 0.785, -1.144e-17 )\nout = base.kernelCos( NaN )\n"
+base.kernelSin,"var y = base.kernelSin( 0.0, 0.0 )\ny = base.kernelSin( PI/6.0, 0.0 )\ny = base.kernelSin( 0.619, 9.279e-18 )\ny = base.kernelSin( NaN, 0.0 )\ny = base.kernelSin( 2.0, NaN )\ny = base.kernelSin( NaN, NaN )\n"
+base.kernelTan,"var out = base.kernelTan( PI/4.0, 0.0, 1 )\nout = base.kernelTan( PI/4.0, 0.0, -1 )\nout = base.kernelTan( PI/6.0, 0.0, 1 )\nout = base.kernelTan( 0.664, 5.288e-17, 1 )\nout = base.kernelTan( NaN, 0.0, 1 )\nout = base.kernelTan( 3.0, NaN, 1 )\nout = base.kernelTan( 3.0, 0.0, NaN )\n"
+base.kroneckerDelta,"var y = base.kroneckerDelta( 3.14, 0.0 )\ny = base.kroneckerDelta( 3.14, 3.14 )\n"
+base.lcm,"var v = base.lcm( 21, 6 )\n"
+base.ldexp,"var x = base.ldexp( 0.5, 3 )\nx = base.ldexp( 4.0, -2 )\nx = base.ldexp( 0.0, 20 )\nx = base.ldexp( -0.0, 39 )\nx = base.ldexp( NaN, -101 )\nx = base.ldexp( PINF, 11 )\nx = base.ldexp( NINF, -118 )\n"
+base.ln,"var y = base.ln( 4.0 )\ny = base.ln( 0.0 )\ny = base.ln( PINF )\ny = base.ln( NaN )\ny = base.ln( -4.0 )\n"
+base.log,"var y = base.log( 100.0, 10.0 )\ny = base.log( 16.0, 2.0 )\ny = base.log( 5.0, 1.0 )\ny = base.log( NaN, 2.0 )\ny = base.log( 1.0, NaN )\ny = base.log( -4.0, 2.0 )\ny = base.log( 4.0, -2.0 )\n"
+base.log1mexp,"var y = base.log1mexp( -10.0 )\ny = base.log1mexp( 0.0 )\ny = base.log1mexp( 5.0 )\ny = base.log1mexp( 10.0 )\ny = base.log1mexp( NaN )\n"
+base.log1p,"var y = base.log1p( 4.0 )\ny = base.log1p( -1.0 )\ny = base.log1p( 0.0 )\ny = base.log1p( -0.0 )\ny = base.log1p( -2.0 )\ny = base.log1p( NaN )\n"
+base.log1pexp,"var y = base.log1pexp( -10.0 )\ny = base.log1pexp( 0.0 )\ny = base.log1pexp( 5.0 )\ny = base.log1pexp( 34.0 )\ny = base.log1pexp( NaN )\n"
+base.log2,"var y = base.log2( 4.0 )\ny = base.log2( 8.0 )\ny = base.log2( 0.0 )\ny = base.log2( PINF )\ny = base.log2( NaN )\ny = base.log2( -4.0 )\n"
+base.log10,"var y = base.log10( 100.0 )\ny = base.log10( 8.0 )\ny = base.log10( 0.0 )\ny = base.log10( PINF )\ny = base.log10( NaN )\ny = base.log10( -4.0 )\n"
+base.logaddexp,"var v = base.logaddexp( 90.0, 90.0 )\nv = base.logaddexp( -20.0, 90.0 )\nv = base.logaddexp( 0.0, -100.0 )\nv = base.logaddexp( NaN, NaN )\n"
+base.logit,"var y = base.logit( 0.2 )\ny = base.logit( 0.9 )\ny = base.logit( -4.0 )\ny = base.logit( 1.5 )\ny = base.logit( NaN )\n"
+base.lucas,"var y = base.lucas( 0 )\ny = base.lucas( 1 )\ny = base.lucas( 2 )\ny = base.lucas( 3 )\ny = base.lucas( 4 )\ny = base.lucas( 77 )\ny = base.lucas( NaN )\n"
+base.lucaspoly,"\n// 2^5 + 5*2^3 + 5*2\nvar v = base.lucaspoly( 5, 2.0 )\n"
+base.max,"var v = base.max( 3.14, 4.2 )\nv = base.max( 5.9, 3.14, 4.2 )\nv = base.max( 3.14, NaN )\nv = base.max( +0.0, -0.0 )\n"
+base.maxabs,"var v = base.maxabs( 3.14, -4.2 )\nv = base.maxabs( 5.9, 3.14, 4.2 )\nv = base.maxabs( 3.14, NaN )\nv = base.maxabs( +0.0, -0.0 )\n"
+base.min,"var v = base.min( 3.14, 4.2 )\nv = base.min( 5.9, 3.14, 4.2 )\nv = base.min( 3.14, NaN )\nv = base.min( +0.0, -0.0 )\n"
+base.minabs,"var v = base.minabs( 3.14, -4.2 )\nv = base.minabs( 5.9, 3.14, 4.2 )\nv = base.minabs( 3.14, NaN )\nv = base.minabs( +0.0, -0.0 )\n"
+base.minmax,"var v = base.minmax( 3.14, 4.2 )\nv = base.minmax( 5.9, 3.14, 4.2 )\nv = base.minmax( 3.14, NaN )\nv = base.minmax( +0.0, -0.0 )\nv = base.minmax( 3.14 )\nvar out = new Array( 2 );\nv = base.minmax( out, 3.14 )\nvar bool = ( v === out )\n"
+base.minmaxabs,"var v = base.minmaxabs( 3.14, 4.2 )\nv = base.minmaxabs( -5.9, 3.14, 4.2 )\nv = base.minmaxabs( 3.14, NaN )\nv = base.minmaxabs( +0.0, -0.0 )\nv = base.minmaxabs( 3.14 )\nvar out = new Array( 2 );\nv = base.minmaxabs( out, 3.14 )\nvar bool = ( v === out )\n"
+base.modf,"var parts = base.modf( 3.14 )\nparts = base.modf( 3.14 )\nparts = base.modf( +0.0 )\nparts = base.modf( -0.0 )\nparts = base.modf( PINF )\nparts = base.modf( NINF )\nparts = base.modf( NaN )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\nparts = base.modf( out, 3.14 )\nvar bool = ( parts === out )\n"
+base.ndarray,"var ctor = base.ndarray( 'float64', 3 )\n\n// To create a new instance...\nvar b = [ 1, 2, 3, 4 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n"
+base.ndarrayMemoized,"var ctor = base.ndarrayMemoized( 'float64', 3 )\nvar f = base.ndarrayMemoized( 'float64', 3 )\nvar bool = ( f === ctor )\n\n// To create a new instance...\nvar b = [ 1, 2, 3, 4 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n"
+base.negafibonacci,"var y = base.negafibonacci( 0 )\ny = base.negafibonacci( -1 )\ny = base.negafibonacci( -2 )\ny = base.negafibonacci( -3 )\ny = base.negafibonacci( -4 )\ny = base.negafibonacci( -79 )\ny = base.negafibonacci( -80 )\ny = base.negafibonacci( NaN )\n"
+base.negalucas,"var y = base.negalucas( 0 )\ny = base.negalucas( -1 )\ny = base.negalucas( -2 )\ny = base.negalucas( -3 )\ny = base.negalucas( -4 )\ny = base.negalucas( -77 )\ny = base.negalucas( -78 )\ny = base.negalucas( NaN )\n"
+base.nonfibonacci,"var v = base.nonfibonacci( 1 )\nv = base.nonfibonacci( 2 )\nv = base.nonfibonacci( 3 )\nv = base.nonfibonacci( NaN )\n"
+base.normalize,"var out = base.normalize( 3.14e-319 )\nvar y = out[ 0 ];\nvar exponent = out[ 1 ];\nvar bool = ( y*base.pow(2.0, exponent) === 3.14e-319 )\n\n// Special cases:\nout = base.normalize( 0.0 )\nout = base.normalize( PINF )\nout = base.normalize( NINF )\nout = base.normalize( NaN )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.normalize( out, 3.14e-319 )\nbool = ( v === out )\n"
+base.normalizef,"var out = base.normalizef( base.float64ToFloat32( 1.401e-45 ) )\nvar y = out[ 0 ];\nvar exp = out[ 1 ];\nvar bool = ( y*base.pow(2,exp) === base.float64ToFloat32(1.401e-45) )\n\n// Special cases:\nout = base.normalizef( FLOAT32_PINF )\nout = base.normalizef( FLOAT32_NINF )\nout = base.normalizef( NaN )\n\n// Provide an output array:\nout = new Float32Array( 2 );\nvar v = base.normalizef( out, base.float64ToFloat32( 1.401e-45 ) )\nbool = ( v === out )\n"
+base.normhermitepoly,"var y = base.normhermitepoly( 1, 0.5 )\ny = base.normhermitepoly( -1, 0.5 )\ny = base.normhermitepoly( 0, 0.5 )\ny = base.normhermitepoly( 2, 0.5 )\n"
+base.pdiff,"var v = base.pdiff( 5.9, 3.14 )\nv = base.pdiff( 3.14, 4.2 )\nv = base.pdiff( 3.14, NaN )\nv = base.pdiff( -0.0, +0.0 )\n"
+base.polygamma,"var v = base.polygamma( 3, 1.2 )\nv = base.polygamma( 5, 1.2 )\nv = base.polygamma( 3, -4.9 )\nv = base.polygamma( -1, 5.3 )\nv = base.polygamma( 2, -1.0 )\n"
+base.pow,"var y = base.pow( 2.0, 3.0 )\ny = base.pow( 4.0, 0.5 )\ny = base.pow( 100.0, 0.0 )\ny = base.pow( PI, 5.0 )\ny = base.pow( PI, -0.2 )\ny = base.pow( NaN, 3.0 )\ny = base.pow( 5.0, NaN )\ny = base.pow( NaN, NaN )\n"
+base.powm1,"var y = base.powm1( 2.0, 3.0 )\ny = base.powm1( 4.0, 0.5 )\ny = base.powm1( 0.0, 100.0 )\ny = base.powm1( 100.0, 0.0 )\ny = base.powm1( 0.0, 0.0 )\ny = base.powm1( PI, 5.0 )\ny = base.powm1( NaN, 3.0 )\ny = base.powm1( 5.0, NaN )\n"
+base.rad2deg,"var d = base.rad2deg( PI/2.0 )\nd = base.rad2deg( -PI/4.0 )\nd = base.rad2deg( NaN )\n\n// Due to finite precision, canonical values may not be returned:\nd = base.rad2deg( PI/6.0 )\n"
+base.ramp,"var y = base.ramp( 3.14 )\ny = base.ramp( -3.14 )\n"
+base.random.arcsine,"var r = base.random.arcsine( 2.0, 5.0 )\n"
+base.random.bernoulli,"var r = base.random.bernoulli( 0.8 );\n"
+base.random.beta,"var r = base.random.beta( 2.0, 5.0 );\n"
+base.random.betaprime,"var r = base.random.betaprime( 2.0, 5.0 );\n"
+base.random.binomial,"var r = base.random.binomial( 20, 0.8 );\n"
+base.random.boxMuller,"var r = base.random.boxMuller();\n"
+base.random.cauchy,"var r = base.random.cauchy( 2.0, 5.0 );\n"
+base.random.chi,"var r = base.random.chi( 2 );\n"
+base.random.chisquare,"var r = base.random.chisquare( 2 );\n"
+base.random.cosine,"var r = base.random.cosine( 2.0, 5.0 );\n"
+base.random.discreteUniform,"var r = base.random.discreteUniform( 2, 50 );\n"
+base.random.erlang,"var r = base.random.erlang( 2, 5.0 );\n"
+base.random.exponential,"var r = base.random.exponential( 7.9 );\n"
+base.random.f,"var r = base.random.f( 2.0, 5.0 );\n"
+base.random.frechet,"var r = base.random.frechet( 2.0, 5.0, 3.33 );\n"
+base.random.gamma,"var r = base.random.gamma( 2.0, 5.0 );\n"
+base.random.geometric,"var r = base.random.geometric( 0.8 );\n"
+base.random.gumbel,"var r = base.random.gumbel( 2.0, 5.0 );\n"
+base.random.hypergeometric,"var r = base.random.hypergeometric( 20, 10, 7 );\n"
+base.random.improvedZiggurat,"var r = base.random.improvedZiggurat();\n"
+base.random.invgamma,"var r = base.random.invgamma( 2.0, 5.0 );\n"
+base.random.kumaraswamy,"var r = base.random.kumaraswamy( 2.0, 5.0 );\n"
+base.random.laplace,"var r = base.random.laplace( 2.0, 5.0 );\n"
+base.random.levy,"var r = base.random.levy( 2.0, 5.0 );\n"
+base.random.logistic,"var r = base.random.logistic( 2.0, 5.0 );\n"
+base.random.lognormal,"var r = base.random.lognormal( 2.0, 5.0 );\n"
+base.random.minstd,"var r = base.random.minstd();\n"
+base.random.minstdShuffle,"var r = base.random.minstdShuffle();\n"
+base.random.mt19937,"var r = base.random.mt19937();\n"
+base.random.negativeBinomial,"var r = base.random.negativeBinomial( 20, 0.8 );\n"
+base.random.normal,"var r = base.random.normal( 2.0, 5.0 );\n"
+base.random.pareto1,"var r = base.random.pareto1( 2.0, 5.0 );\n"
+base.random.poisson,"var r = base.random.poisson( 7.9 );\n"
+base.random.randi,"var r = base.random.randi();\n"
+base.random.randn,"var r = base.random.randn();\n"
+base.random.randu,"var r = base.random.randu();\n"
+base.random.rayleigh,"var r = base.random.rayleigh( 2.5 );\n"
+base.random.t,"var r = base.random.t( 2.0 );\n"
+base.random.triangular,"var r = base.random.triangular( 2.0, 5.0, 3.33 );\n"
+base.random.uniform,"var r = base.random.uniform( 2.0, 5.0 );\n"
+base.random.weibull,"var r = base.random.weibull( 2.0, 5.0 );\n"
+base.reldiff,"var d = base.reldiff( 2.0, 5.0 )\nd = base.reldiff( -1.0, 3.14 )\nd = base.reldiff( -2.0, 5.0, 'max-abs' )\nd = base.reldiff( -2.0, 5.0, 'max' )\nd = base.reldiff( -2.0, 5.0, 'min-abs' )\nd = base.reldiff( -2.0, 5.0, 'min' )\nd = base.reldiff( -2.0, 5.0, 'mean-abs' )\nd = base.reldiff( -2.0, 5.0, 'mean' )\nd = base.reldiff( -2.0, 5.0, 'x' )\nd = base.reldiff( 5.0, -2.0, 'x' )\nd = base.reldiff( -2.0, 5.0, 'y' )\nd = base.reldiff( 5.0, -2.0, 'y' )\n\n// Custom scale function:\nfunction scale( x, y ) {\n var s;\n ...\n x = base.abs( x );\n y = base.abs( y );\n ...\n // Maximum absolute value:\n s = (x < y ) ? y : x;\n ...\n // Scale in units of epsilon:\n return s * EPS;\n};\nd = base.reldiff( 12.15, 12.149999999999999, scale )\n"
+base.rempio2,"var y = new Array( 2 );\nvar n = base.rempio2( 128.0, y )\nvar y1 = y[ 0 ]\nvar y2 = y[ 1 ]\n"
+base.risingFactorial,"var v = base.risingFactorial( 0.9, 5 )\nv = base.risingFactorial( -9.0, 3 )\nv = base.risingFactorial( 0.0, 2 )\nv = base.risingFactorial( 3.0, -2 )\n"
+base.rotl32,"var x = 2147483649;\nvar bStr = base.toBinaryStringUint32( x )\nvar y = base.rotl32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n"
+base.rotr32,"var x = 1;\nvar bStr = base.toBinaryStringUint32( x )\nvar y = base.rotr32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n"
+base.round,"var y = base.round( 3.14 )\ny = base.round( -4.2 )\ny = base.round( -4.6 )\ny = base.round( 9.5 )\ny = base.round( -0.0 )\n"
+base.round2,"var y = base.round2( 3.14 )\ny = base.round2( -4.2 )\ny = base.round2( -4.6 )\ny = base.round2( 9.5 )\ny = base.round2( 13.0 )\ny = base.round2( -13.0 )\ny = base.round2( -0.0 )\n"
+base.round10,"var y = base.round10( 3.14 )\ny = base.round10( -4.2 )\ny = base.round10( -4.6 )\ny = base.round10( 9.5 )\ny = base.round10( 13.0 )\ny = base.round10( -13.0 )\ny = base.round10( -0.0 )\n"
+base.roundb,"\n// Round to 2 decimal places:\nvar y = base.roundb( 3.14159, -2, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.roundb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two:\ny = base.roundb( 5.0, 1, 2 )\n"
+base.roundn,"\n// Round to 2 decimal places:\nvar y = base.roundn( 3.14159, -2 )\n\n// If `n = 0`, standard round behavior:\ny = base.roundn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.roundn( 12368.0, 3 )\n"
+base.roundsd,"var y = base.roundsd( 3.14159, 3 )\ny = base.roundsd( 3.14159, 1 )\ny = base.roundsd( 12368.0, 2 )\ny = base.roundsd( 0.0313, 2, 2 )\n"
+base.rsqrt,"var y = base.rsqrt( 4.0 )\ny = base.rsqrt( 100.0 )\ny = base.rsqrt( 0.0 )\ny = base.rsqrt( Infinity )\ny = base.rsqrt( -4.0 )\ny = base.rsqrt( NaN )\n"
+base.sasum,"\n// Standard usage:\nvar x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nvar sum = base.sasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.sasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float32Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.sasum( N, x1, stride )\n"
+base.saxpy,"\n// Standard usage:\nvar x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nvar alpha = 5.0;\nbase.saxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\nbase.saxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.saxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n"
+base.scopy,"\n// Standard usage:\nvar x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.scopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar N = base.floor( x.length / 2 );\nbase.scopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.scopy( N, x1, -2, y1, 1 )\ny0\n"
+base.setHighWord,"\n// Set the higher order bits of `+infinity` to return `1`:\nvar high = 1072693248 >>> 0;\nvar y = base.setHighWord( PINF, high )\n"
+base.setLowWord,"var low = 5 >>> 0;\nvar x = 3.14e201;\nvar y = base.setLowWord( x, low )\n\n// Special cases:\nvar low = 12345678;\nvar y = base.setLowWord( PINF, low )\ny = base.setLowWord( NINF, low )\ny = base.setLowWord( NaN, low )\n"
+base.sici,"var y = base.sici( 3.0 )\ny = base.sici( 0.0 )\ny = base.sici( -9.0 )\ny = base.sici( NaN )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\ny = base.sici( out, 3.0 )\nvar bool = ( y === out )\n"
+base.signbit,"var bool = base.signbit( 4.0 )\nbool = base.signbit( -9.14e-34 )\nbool = base.signbit( 0.0 )\nbool = base.signbit( -0.0 )\n"
+base.signbitf,"var bool = base.signbitf( base.float64ToFloat32( 4.0 ) )\nbool = base.signbitf( base.float64ToFloat32( -9.14e-34 ) )\nbool = base.signbitf( 0.0 )\nbool = base.signbitf( -0.0 )\n"
+base.significandf,"var s = base.significandf( base.float64ToFloat32( 3.14e34 ) )\ns = base.significandf( base.float64ToFloat32( 3.14e-34 ) )\ns = base.significandf( base.float64ToFloat32( -3.14 ) )\ns = base.significandf( 0.0 )\ns = base.significandf( NaN )\n"
+base.signum,"var sign = base.signum( -5.0 )\nsign = base.signum( 5.0 )\nsign = base.signum( -0.0 )\nsign = base.signum( 0.0 )\nsign = base.signum( NaN )\n"
+base.sin,"var y = base.sin( 0.0 )\ny = base.sin( PI/2.0 )\ny = base.sin( -PI/6.0 )\ny = base.sin( NaN )\n"
+base.sinc,"var y = base.sinc( 0.5 )\ny = base.sinc( -1.2 )\ny = base.sinc( 0.0 )\ny = base.sinc( NaN )\n"
+base.sincos,"var y = base.sincos( 0.0 )\ny = base.sincos( PI/2.0 )\ny = base.sincos( -PI/6.0 )\ny = base.sincos( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.sincos( out, 0.0 )\nvar bool = ( v === out )\n"
+base.sincospi,"var y = base.sincospi( 0.0 )\ny = base.sincospi( 0.5 )\ny = base.sincospi( 0.1 )\ny = base.sincospi( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.sincospi( out, 0.0 )\nvar bool = ( v === out )\n"
+base.sinh,"var y = base.sinh( 0.0 )\ny = base.sinh( 2.0 )\ny = base.sinh( -2.0 )\ny = base.sinh( NaN )\n"
+base.sinpi,"var y = base.sinpi( 0.0 )\ny = base.sinpi( 0.5 )\ny = base.sinpi( 0.9 )\ny = base.sinpi( NaN )\n"
+base.spence,"var y = base.spence( 3.0 )\ny = base.spence( 0.0 )\ny = base.spence( -9.0 )\ny = base.spence( NaN )\n"
+base.sqrt,"var y = base.sqrt( 4.0 )\ny = base.sqrt( 9.0 )\ny = base.sqrt( 0.0 )\ny = base.sqrt( -4.0 )\ny = base.sqrt( NaN )\n"
+base.sqrt1pm1,"var y = base.sqrt1pm1( 3.0 )\ny = base.sqrt1pm1( 0.5 )\ny = base.sqrt1pm1( 0.02 )\ny = base.sqrt1pm1( -0.5 )\ny = base.sqrt1pm1( -1.1 )\ny = base.sqrt1pm1( NaN )\n"
+base.sumSeries,"\n// Using an ES6 generator function:\nfunction* geometricSeriesGenerator( x ) {\n var exponent = 0;\n while ( true ) {\n yield Math.pow( x, exponent );\n exponent += 1;\n }\n};\nvar gen = geometricSeriesGenerator( 0.9 );\nvar out = base.sumSeries( gen )\n\n// Using a closure:\nfunction geometricSeriesClosure( x ) {\n var exponent = -1;\n return function() {\n exponent += 1;\n return Math.pow( x, exponent );\n };\n};\ngen = geometricSeriesClosure( 0.9 );\nout = base.sumSeries( gen )\n\n// Setting an initial value for the sum:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'initialValue': 1 } )\n\n// Changing the maximum number of terms to be summed:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'maxTerms': 10 } )\n\n// Adjusting the used tolerance:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'tolerance': 1e-3 } )\n"
+base.tan,"var y = base.tan( 0.0 )\ny = base.tan( -PI/4.0 )\ny = base.tan( PI/4.0 )\ny = base.tan( NaN )\n"
+base.tanh,"var y = base.tanh( 0.0 )\nvar y = base.tanh( -0.0 )\ny = base.tanh( 2.0 )\ny = base.tanh( -2.0 )\ny = base.tanh( NaN )\n"
+base.toBinaryString,"var str = base.toBinaryString( 4.0 )\nstr = base.toBinaryString( PI )\nstr = base.toBinaryString( -1.0e308 )\nstr = base.toBinaryString( -3.14e-320 )\nstr = base.toBinaryString( 5.0e-324 )\nstr = base.toBinaryString( 0.0 )\nstr = base.toBinaryString( -0.0 )\nstr = base.toBinaryString( NaN )\nstr = base.toBinaryString( PINF )\nstr = base.toBinaryString( NINF )\n"
+base.toBinaryStringf,"var str = base.toBinaryStringf( base.float64ToFloat32( 4.0 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( PI ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -1.0e38 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -3.14e-39 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( 1.4e-45 ) )\nstr = base.toBinaryStringf( 0.0 )\nstr = base.toBinaryStringf( -0.0 )\nstr = base.toBinaryStringf( NaN )\nstr = base.toBinaryStringf( FLOAT32_PINF )\nstr = base.toBinaryStringf( FLOAT32_NINF )\n"
+base.toBinaryStringUint8,"var a = new Uint8Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint8( a[ 0 ] )\nstr = base.toBinaryStringUint8( a[ 1 ] )\nstr = base.toBinaryStringUint8( a[ 2 ] )\n"
+base.toBinaryStringUint16,"var a = new Uint16Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint16( a[ 0 ] )\nstr = base.toBinaryStringUint16( a[ 1 ] )\nstr = base.toBinaryStringUint16( a[ 2 ] )\n"
+base.toBinaryStringUint32,"var a = new Uint32Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint32( a[ 0 ] )\nstr = base.toBinaryStringUint32( a[ 1 ] )\nstr = base.toBinaryStringUint32( a[ 2 ] )\n"
+base.toWordf,"var f32 = base.float64ToFloat32( 1.337 )\nvar w = base.toWordf( f32 )\n"
+base.toWords,"var w = base.toWords( 3.14e201 )\n\n// Provide an output array:\nvar out = new Uint32Array( 2 );\nw = base.toWords( out, 3.14e201 )\nvar bool = ( w === out )\n"
+base.trigamma,"var y = base.trigamma( -2.5 )\ny = base.trigamma( 1.0 )\ny = base.trigamma( 10.0 )\ny = base.trigamma( NaN )\ny = base.trigamma( -1.0 )\n"
+base.trunc,"var y = base.trunc( 3.14 )\ny = base.trunc( -4.2 )\ny = base.trunc( -4.6 )\ny = base.trunc( 9.5 )\ny = base.trunc( -0.0 )\n"
+base.trunc2,"var y = base.trunc2( 3.14 )\ny = base.trunc2( -4.2 )\ny = base.trunc2( -4.6 )\ny = base.trunc2( 9.5 )\ny = base.trunc2( 13.0 )\ny = base.trunc2( -13.0 )\ny = base.trunc2( -0.0 )\n"
+base.trunc10,"var y = base.trunc10( 3.14 )\ny = base.trunc10( -4.2 )\ny = base.trunc10( -4.6 )\ny = base.trunc10( 9.5 )\ny = base.trunc10( 13.0 )\ny = base.trunc10( -13.0 )\ny = base.trunc10( -0.0 )\n"
+base.truncb,"\n// Round to 4 decimal places:\nvar y = base.truncb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.truncb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward zero:\ny = base.truncb( 5.0, 1, 2 )\n"
+base.truncn,"\n// Round to 4 decimal places:\nvar y = base.truncn( 3.14159, -4 )\n\n// If `n = 0`, standard round behavior:\ny = base.truncn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.truncn( 12368.0, 3 )\n"
+base.truncsd,"var y = base.truncsd( 3.14159, 5 )\ny = base.truncsd( 3.14159, 1 )\ny = base.truncsd( 12368.0, 2 )\ny = base.truncsd( 0.0313, 2, 2 )\n"
+base.uimul,"var v = base.uimul( 10>>>0, 4>>>0 )\n"
+base.uimuldw,"var v = base.uimuldw( 1, 10 )\n"
+base.uint32ToInt32,"var y = base.uint32ToInt32( base.float64ToUint32( 4294967295 ) )\ny = base.uint32ToInt32( base.float64ToUint32( 3 ) )\n"
+base.vercos,"var y = base.vercos( 3.14 )\ny = base.vercos( -4.2 )\ny = base.vercos( -4.6 )\ny = base.vercos( 9.5 )\ny = base.vercos( -0.0 )\n"
+base.versin,"var y = base.versin( 3.14 )\ny = base.versin( -4.2 )\ny = base.versin( -4.6 )\ny = base.versin( 9.5 )\ny = base.versin( -0.0 )\n"
+base.wrap,"var y = base.wrap( 3.14, 0.0, 5.0 )\ny = base.wrap( -3.14, 0.0, 5.0 )\ny = base.wrap( 3.14, 0.0, 3.0 )\ny = base.wrap( -0.0, 0.0, 5.0 )\ny = base.wrap( 0.0, -3.14, -0.0 )\ny = base.wrap( NaN, 0.0, 5.0 )\n"
+base.xlog1py,"var out = base.xlog1py( 3.0, 2.0 )\nout = base.xlog1py( 1.5, 5.9 )\nout = base.xlog1py( 0.9, 1.0 )\nout = base.xlog1py( 1.0, 0.0 )\nout = base.xlog1py( 0.0, -2.0 )\nout = base.xlog1py( 1.5, NaN )\nout = base.xlog1py( 0.0, NaN )\nout = base.xlog1py( NaN, 2.3 )\n"
+base.xlogy,"var out = base.xlogy( 3.0, 2.0 )\nout = base.xlogy( 1.5, 5.9 )\nout = base.xlogy( 0.9, 1.0 )\nout = base.xlogy( 0.0, -2.0 )\nout = base.xlogy( 1.5, NaN )\nout = base.xlogy( 0.0, NaN )\nout = base.xlogy( NaN, 2.3 )\n"
+base.zeta,"var y = base.zeta( 1.1 )\ny = base.zeta( -4.0 )\ny = base.zeta( 70.0 )\ny = base.zeta( 0.5 )\ny = base.zeta( NaN )\n\n// Evaluate at a pole:\ny = base.zeta( 1.0 )\n"
+BERNDT_CPS_WAGES_1985,"var data = BERNDT_CPS_WAGES_1985()\n"
+bifurcate,"var collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar f = [ true, true, false, true ];\nvar out = bifurcate( collection, f )\nf = [ 1, 1, 0, 1 ];\nout = bifurcate( collection, f )\n\n// Output group results as indices:\nf = [ true, true, false, true ];\nvar opts = { 'returns': 'indices' };\nout = bifurcate( collection, opts, f )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = bifurcate( collection, opts, f )\n"
+bifurcateBy,"function predicate( v ) { return v[ 0 ] === 'b'; };\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = bifurcateBy( collection, predicate )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nout = bifurcateBy( collection, opts, predicate )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateBy( collection, opts, predicate )\n"
+bifurcateByAsync,"\n// Basic usage:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, predicate, done )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n"
+bifurcateIn,"function Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nvar obj = new Foo();\nfunction predicate( v ) { return v[ 0 ] === 'b'; };\nvar out = bifurcateIn( obj, predicate )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = bifurcateIn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateIn( obj, opts, predicate )\n"
+bifurcateOwn,"function predicate( v ) { return v[ 0 ] === 'b'; };\nvar obj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nvar out = bifurcateOwn( obj, predicate )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = bifurcateOwn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateOwn( obj, opts, predicate )\n"
+binomialTest,"var out = binomialTest( 682, 925 )\nout = binomialTest( [ 682, 925 - 682 ] )\nout = binomialTest( 21, 40, {\n 'p': 0.4,\n 'alternative': 'greater'\n})\n"
+Buffer,"var b = new Buffer( 4 )\n"
+buffer2json,"var buf = new allocUnsafe( 2 );\nbuf[ 0 ] = 1;\nbuf[ 1 ] = 2;\nvar json = buffer2json( buf )\n"
+capitalize,"var out = capitalize( 'beep' )\nout = capitalize( 'Boop' )\n"
+capitalizeKeys,"var obj = { 'aa': 1, 'bb': 2 };\nvar out = capitalizeKeys( obj )\n"
+CATALAN,"CATALAN\n"
+CBRT_EPS,"CBRT_EPS\n"
+chdir,"var err = chdir( '/path/to/current/working/directory' )\n"
+chi2gof,"\n// Provide expected probabilities...\nvar x = [ 89, 37, 30, 28, 2 ];\nvar p = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nvar out = chi2gof( x, p )\nout.print()\n\n// Set significance level...\nvar opts = { 'alpha': 0.01 };\nout = chi2gof( x, p, opts );\nout.print()\n\n// Calculate the test p-value via Monte Carlo simulation...\nx = [ 89, 37, 30, 28, 2 ];\np = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nopts = { 'simulate': true, 'iterations': 1000 };\nout = chi2gof( x, p, opts )\n\n// Verify that data comes from Poisson distribution...\nvar lambda = 3.0;\nvar rpois = base.random.poisson.factory( lambda );\nvar len = 400;\nx = [];\nfor ( var i = 0; i < len; i++ ) { x.push( rpois() ); };\n\n// Generate a frequency table...\nvar freqs = new Int32Array( len );\nfor ( i = 0; i < len; i++ ) { freqs[ x[ i ] ] += 1; };\nout = chi2gof( freqs, 'poisson', lambda )\n"
+circarray2iterator,"var it = circarray2iterator( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n"
+circularArrayStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 15 };\nvar s = circularArrayStream( [ 1, 2, 3 ], opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+CircularBuffer,"var b = CircularBuffer( 3 );\nb.push( 'foo' );\nb.push( 'bar' );\nb.push( 'beep' );\nb.length\nb.count\nb.push( 'boop' )\n"
+CMUDICT,"var data = CMUDICT();\nvar dict = data.dict\nvar phones = data.phones\nvar symbols = data.symbols\nvar vp = data.vp\n"
+complex,"var z = complex( 5.0, 3.0, 'float64' )\nz = complex( 5.0, 3.0, 'float32' )\n"
+Complex64,"var z = new Complex64( 5.0, 3.0 )\nz.re\nz.im\n"
+COMPLEX64_NUM_BYTES,"COMPLEX64_NUM_BYTES\n"
+Complex128,"var z = new Complex128( 5.0, 3.0 )\nz.re\nz.im\n"
+COMPLEX128_NUM_BYTES,"COMPLEX128_NUM_BYTES\n"
+compose,"function a( x ) {\n return 2 * x;\n}\nfunction b( x ) {\n return x + 3;\n}\nfunction c( x ) {\n return x / 5;\n}\nvar f = compose( c, b, a );\nvar z = f( 6 )\n"
+composeAsync,"function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nvar f = composeAsync( c, b, a );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n"
+configdir,"var dir = configdir()\ndir = configdir( 'appname/config' )\n"
+conj,"var z = new Complex128( 5.0, 3.0 );\nz.toString()\nvar v = conj( z );\nv.toString()\n"
+constantFunction,"var fcn = constantFunction( 3.14 );\nvar v = fcn()\nv = fcn()\nv = fcn()\n"
+constantStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = constantStream( 'beep', opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+constructorName,"var v = constructorName( 'a' )\nv = constructorName( {} )\nv = constructorName( true )\n"
+contains,"var bool = contains( 'Hello World', 'World' )\nbool = contains( 'Hello World', 'world' )\nbool = contains( [ 1, 2, 3, 4 ], 2 )\nbool = contains( [ NaN, 2, 3, 4 ], NaN )\n\n// Supply a position:\nbool = contains( 'Hello World', 'Hello', 6 )\nbool = contains( [ true, NaN, false ], true, 1 )\n"
+convertArray,"var arr = [ 1.0, 2.0, 3.0, 4.0 ];\nvar out = convertArray( arr, 'float32' )\n"
+convertArraySame,"var x = [ 1.0, 2.0, 3.0, 4.0 ];\nvar y = new Float32Array( 0 );\nvar out = convertArraySame( x, y )\n"
+convertPath,"var out = convertPath( '/c/foo/bar/beep.c', 'win32' )\nout = convertPath( '/c/foo/bar/beep.c', 'mixed' )\nout = convertPath( '/c/foo/bar/beep.c', 'posix' )\nout = convertPath( 'C:\\\\foo\\bar\\beep.c', 'win32' )\nout = convertPath( 'C:\\\\foo\\bar\\beep.c', 'mixed' )\nout = convertPath( 'C:\\\\foo\\bar\\beep.c', 'posix' )\n"
+copy,"var value = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nvar out = copy( value )\nvar bool = ( value[ 0 ].c === out[ 0 ].c )\n\n// Set the `level` option to limit the copy depth:\nvalue = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nout = copy( value, 1 );\nbool = ( value[ 0 ] === out[ 0 ] )\nbool = ( value[ 0 ].c === out[ 0 ].c )\n"
+copyBuffer,"var b1 = array2buffer( [ 1, 2, 3, 4 ] );\nvar b2 = copyBuffer( b1 )\n"
+countBy,"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = countBy( collection, indicator )\n"
+countByAsync,"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n"
+curry,"function add( x, y ) { return x + y; };\nvar f = curry( add );\nvar sum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curry( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nvar obj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curry( obj.greet, obj );\nvar str = f( 'Hello' )( 'there' )\n"
+curryRight,"function add( x, y ) { return x + y; };\nvar f = curryRight( add );\nvar sum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curryRight( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nvar obj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curryRight( obj.greet, obj );\nvar str = f( 'there' )( 'Hello' )\n"
+cwd,"var dir = cwd()\n"
+DALE_CHALL_NEW,"var list = DALE_CHALL_NEW()\n"
+datasets,"var out = datasets( 'MONTH_NAMES_EN' )\nvar opts = { 'data': 'cities' };\nout = datasets( 'MINARD_NAPOLEONS_MARCH', opts )\n"
+dayOfQuarter,"var day = dayOfQuarter()\nday = dayOfQuarter( new Date() )\nday = dayOfQuarter( 12, 31, 2017 )\n\n// Other ways to supply month:\nday = dayOfQuarter( 'dec', 31, 2017 )\nday = dayOfQuarter( 'december', 31, 2017 )\n"
+dayOfYear,"var day = dayOfYear()\nday = dayOfYear( new Date() )\nday = dayOfYear( 12, 31, 2016 )\n\n// Other ways to supply month:\nday = dayOfYear( 'dec', 31, 2016 )\nday = dayOfYear( 'december', 31, 2016 )\n"
+daysInMonth,"var num = daysInMonth()\nnum = daysInMonth( 2 )\nnum = daysInMonth( 2, 2016 )\nnum = daysInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = daysInMonth( 'feb', 2016 )\nnum = daysInMonth( 'february', 2016 )\n"
+daysInYear,"var num = daysInYear()\nnum = daysInYear( 2016 )\nnum = daysInYear( 2017 )\n"
+debugSinkStream,"var s = debugSinkStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+debugStream,"var s = debugStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+deepEqual,"var bool = deepEqual( [ 1, 2, 3 ], [ 1, 2, 3 ] )\nbool = deepEqual( [ 1, 2, 3 ], [ 1, 2, '3' ] )\nbool = deepEqual( { 'a': 2 }, { 'a': [ 2 ] } )\n"
+deepGet,"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar val = deepGet( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nvar obj = { 'a': { 'b': { 'c': 'd' } } };\nvar val = deepGet( obj, 'a/b/c', { 'sep': '/' } )\n"
+deepHasOwnProp,"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar bool = deepHasOwnProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepHasOwnProp( obj, 'a/b/c', { 'sep': '/' } )\n"
+deepHasProp,"function Foo() { return this; };\nFoo.prototype.b = { 'c': 'd' };\nvar obj = { 'a': new Foo() };\nvar bool = deepHasProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nbool = deepHasProp( obj, 'a/b/c', { 'sep': '/' } )\n"
+deepPluck,"var arr = [\n { 'a': { 'b': { 'c': 1 } } },\n { 'a': { 'b': { 'c': 2 } } }\n];\nvar out = deepPluck( arr, 'a.b.c' )\narr = [\n { 'a': [ 0, 1, 2 ] },\n { 'a': [ 3, 4, 5 ] }\n];\nout = deepPluck( arr, [ 'a', 1 ] )\n"
+deepSet,"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar bool = deepSet( obj, 'a.b.c', 'beep' )\n\n// Specify an alternative separator via the sep option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepSet( obj, 'a/b/c', 'beep', { 'sep': '/' } );\nobj\n\n// To create a key path which does not exist, set the create option to true:\nbool = deepSet( obj, 'a.e.c', 'boop', { 'create': true } );\nobj\n"
+defineMemoizedProperty,"var obj = {};\nfunction foo() {\n return 'bar';\n};\ndefineMemoizedProperty( obj, 'foo', {\n 'configurable': false,\n 'enumerable': true,\n 'writable': false,\n 'value': foo\n});\nobj.foo\n"
+defineProperties,"var obj = {};\ndefineProperties( obj, {\n 'foo': {\n 'value': 'bar',\n 'writable': false,\n 'configurable': false,\n 'enumerable': true\n },\n 'baz': {\n 'value': 13\n }\n});\nobj.foo\nobj.baz\n"
+defineProperty,"var obj = {};\ndefineProperty( obj, 'foo', {\n 'value': 'bar',\n 'enumerable': true,\n 'writable': false\n});\nobj.foo = 'boop';\nobj\n"
+dirname,"var dir = dirname( './foo/bar/index.js' )\n"
+DoublyLinkedList,"var list = DoublyLinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n"
+doUntil,"function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoUntil( beep, predicate )\n"
+doUntilAsync,"function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoUntilAsync( fcn, predicate, done )\n"
+doUntilEach,"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\ndoUntilEach( arr, logger, predicate )\n"
+doUntilEachRight,"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\ndoUntilEachRight( arr, logger, predicate )\n"
+doWhile,"function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoWhile( beep, predicate )\n"
+doWhileAsync,"function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoWhileAsync( fcn, predicate, done )\n"
+doWhileEach,"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\ndoWhileEach( arr, logger, predicate )\n"
+doWhileEachRight,"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\ndoWhileEachRight( arr, logger, predicate )\n"
+E,"E\n"
+emptyStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = emptyStream();\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+endsWith,"var bool = endsWith( 'beep', 'ep' )\nbool = endsWith( 'Beep', 'op' )\nbool = endsWith( 'Beep', 'ee', 3 )\nbool = endsWith( 'Beep', 'ee', -1 )\nbool = endsWith( 'beep', '' )\n"
+enumerableProperties,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = enumerableProperties( obj )\n"
+enumerablePropertiesIn,"var props = enumerablePropertiesIn( [] )\n"
+enumerablePropertySymbols,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = enumerablePropertySymbols( obj )\n"
+enumerablePropertySymbolsIn,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = enumerablePropertySymbolsIn( obj )\n"
+ENV,"var user = ENV.USER\n"
+EPS,"EPS\n"
+error2json,"var err = new Error( 'beep' );\nvar json = error2json( err )\n"
+EULERGAMMA,"EULERGAMMA\n"
+every,"var arr = [ 1, 1, 1, 1, 1 ];\nvar bool = every( arr )\n"
+everyBy,"function positive( v ) { return ( v > 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = everyBy( arr, positive )\n"
+everyByAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n"
+everyByRight,"function positive( v ) { return ( v > 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = everyByRight( arr, positive )\n"
+everyByRightAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n"
+evil,"var v = evil( '5*4*3*2*1' )\n"
+exists,"function done( error, bool ) { console.log( bool ); };\nexists( './beep/boop', done );\n"
+expandContractions,"var str = 'I won\'t be able to get y\'all out of this one.';\nvar out = expandContractions( str )\nstr = 'It oughtn\'t to be my fault, because, you know, I didn\'t know';\nout = expandContractions( str )\n"
+extname,"var ext = extname( 'index.js' )\n"
+fastmath.abs,"var v = fastmath.abs( -1.0 )\nv = fastmath.abs( 2.0 )\nv = fastmath.abs( 0.0 )\nv = fastmath.abs( -0.0 )\nv = fastmath.abs( NaN )\n"
+fastmath.acosh,"var v = fastmath.acosh( 1.0 )\nv = fastmath.acosh( 2.0 )\nv = fastmath.acosh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.acosh( 1.0e308 )\n"
+fastmath.ampbm,"var h = fastmath.ampbm( 5.0, 12.0 )\n"
+fastmath.asinh,"var v = fastmath.asinh( 0.0 )\nv = fastmath.asinh( 2.0 )\nv = fastmath.asinh( -2.0 )\nv = fastmath.asinh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.asinh( 1.0e200 )\n\n// The function underflows for small `x`:\nv = fastmath.asinh( 1.0e-50 )\n"
+fastmath.atanh,"var v = fastmath.atanh( 0.0 )\nv = fastmath.atanh( 0.9 )\nv = fastmath.atanh( 1.0 )\nv = fastmath.atanh( -1.0 )\nv = fastmath.atanh( NaN )\n\n// The function underflows for small `x`:\nv = fastmath.atanh( 1.0e-17 )\n"
+fastmath.hypot,"var h = fastmath.hypot( -5.0, 12.0 )\n\n// For a sufficiently large `x` and/or `y`, the function overflows:\nh = fastmath.hypot( 1.0e154, 1.0e154 )\n\n// For sufficiently small `x` and/or `y`, the function underflows:\nh = fastmath.hypot( 1e-200, 1.0e-200 )\n"
+fastmath.log2Uint32,"var v = fastmath.log2Uint32( 4 >>> 0 )\nv = fastmath.log2Uint32( 8 >>> 0 )\nv = fastmath.log2Uint32( 9 >>> 0 )\n"
+fastmath.max,"var v = fastmath.max( 3.14, 4.2 )\nv = fastmath.max( 3.14, NaN )\nv = fastmath.max( NaN, 3.14 )\nv = fastmath.max( -0.0, +0.0 )\nv = fastmath.max( +0.0, -0.0 )\n"
+fastmath.min,"var v = fastmath.min( 3.14, 4.2 )\nv = fastmath.min( 3.14, NaN )\nv = fastmath.min( NaN, 3.14 )\nv = fastmath.min( -0.0, +0.0 )\nv = fastmath.min( +0.0, -0.0 )\n"
+fastmath.powint,"var v = fastmath.powint( 2.0, 3 )\nv = fastmath.powint( 3.14, 0 )\nv = fastmath.powint( 2.0, -2 )\nv = fastmath.powint( 0.0, 0 )\nv = fastmath.powint( -3.14, 1 )\nv = fastmath.powint( NaN, 0 )\n"
+fastmath.sqrtUint32,"var v = fastmath.sqrtUint32( 9 >>> 0 )\nv = fastmath.sqrtUint32( 2 >>> 0 )\nv = fastmath.sqrtUint32( 3 >>> 0 )\nv = fastmath.sqrtUint32( 0 >>> 0 )\n"
+FEMALE_FIRST_NAMES_EN,"var list = FEMALE_FIRST_NAMES_EN()\n"
+FIFO,"var q = FIFO();\nq.push( 'foo' ).push( 'bar' );\nq.length\nq.pop()\nq.length\nq.pop()\nq.length\n"
+find,"var data = [ 30, 20, 50, 60, 10 ];\nfunction condition( val ) { return val > 20; };\nvar vals = find( data, condition )\n\n// Limit number of results:\ndata = [ 30, 20, 50, 60, 10 ];\nvar opts = { 'k': 2, 'returns': 'values' };\nvals = find( data, opts, condition )\n\n// Return both indices and values as index-value pairs:\ndata = [ 30, 20, 50, 60, 10 ];\nopts = { 'k': -2, 'returns': '*' };\nvals = find( data, opts, condition )\n"
+flattenArray,"var arr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nvar out = flattenArray( arr )\n\n// Set the maximum depth:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2 } )\nvar bool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n\n// Deep copy:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2, 'copy': true } )\nbool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n"
+flattenObject,"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar out = flattenObject( obj )\n\n// Set the `depth` option to flatten to a specified depth:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'depth': 1 } )\nvar bool = ( obj.a.b === out[ 'a.b' ] )\n\n// Set the `delimiter` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'delimiter': '-|-' } )\n\n// Flatten arrays:\nobj = { 'a': { 'b': [ 1, 2, 3 ] } };\nout = flattenObject( obj, { 'flattenArrays': true } )\n"
+flignerTest,"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = flignerTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = flignerTest( arr, { 'groups': groups })\n"
+FLOAT16_CBRT_EPS,"FLOAT16_CBRT_EPS\n"
+FLOAT16_EPS,"FLOAT16_EPS\n"
+FLOAT16_EXPONENT_BIAS,"FLOAT16_EXPONENT_BIAS\n"
+FLOAT16_MAX,"FLOAT16_MAX\n"
+FLOAT16_MAX_SAFE_INTEGER,"FLOAT16_MAX_SAFE_INTEGER\n"
+FLOAT16_MIN_SAFE_INTEGER,"FLOAT16_MIN_SAFE_INTEGER\n"
+FLOAT16_NINF,"FLOAT16_NINF\n"
+FLOAT16_NUM_BYTES,"FLOAT16_NUM_BYTES\n"
+FLOAT16_PINF,"FLOAT16_PINF\n"
+FLOAT16_PRECISION,"FLOAT16_PRECISION\n"
+FLOAT16_SMALLEST_NORMAL,"FLOAT16_SMALLEST_NORMAL\n"
+FLOAT16_SMALLEST_SUBNORMAL,"FLOAT16_SMALLEST_SUBNORMAL\n"
+FLOAT16_SQRT_EPS,"FLOAT16_SQRT_EPS\n"
+FLOAT32_CBRT_EPS,"FLOAT32_CBRT_EPS\n"
+FLOAT32_EPS,"FLOAT32_EPS\n"
+FLOAT32_EXPONENT_BIAS,"FLOAT32_EXPONENT_BIAS\n"
+FLOAT32_MAX,"FLOAT32_MAX\n"
+FLOAT32_MAX_SAFE_INTEGER,"FLOAT32_MAX_SAFE_INTEGER\n"
+FLOAT32_MIN_SAFE_INTEGER,"FLOAT32_MIN_SAFE_INTEGER\n"
+FLOAT32_NINF,"FLOAT32_NINF\n"
+FLOAT32_NUM_BYTES,"FLOAT32_NUM_BYTES\n"
+FLOAT32_PINF,"FLOAT32_PINF\n"
+FLOAT32_PRECISION,"FLOAT32_PRECISION\n"
+FLOAT32_SMALLEST_NORMAL,"FLOAT32_SMALLEST_NORMAL\n"
+FLOAT32_SMALLEST_SUBNORMAL,"FLOAT32_SMALLEST_SUBNORMAL\n"
+FLOAT32_SQRT_EPS,"FLOAT32_SQRT_EPS\n"
+Float32Array,"var arr = new Float32Array()\n"
+FLOAT64_EXPONENT_BIAS,"FLOAT64_EXPONENT_BIAS\n"
+FLOAT64_HIGH_WORD_EXPONENT_MASK,"FLOAT64_HIGH_WORD_EXPONENT_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_EXPONENT_MASK )\n"
+FLOAT64_HIGH_WORD_SIGNIFICAND_MASK,"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_SIGNIFICAND_MASK )\n"
+FLOAT64_MAX,"FLOAT64_MAX\n"
+FLOAT64_MAX_BASE2_EXPONENT,"FLOAT64_MAX_BASE2_EXPONENT\n"
+FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL\n"
+FLOAT64_MAX_BASE10_EXPONENT,"FLOAT64_MAX_BASE10_EXPONENT\n"
+FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL,"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL\n"
+FLOAT64_MAX_LN,"FLOAT64_MAX_LN\n"
+FLOAT64_MAX_SAFE_FIBONACCI,"FLOAT64_MAX_SAFE_FIBONACCI\n"
+FLOAT64_MAX_SAFE_INTEGER,"FLOAT64_MAX_SAFE_INTEGER\n"
+FLOAT64_MAX_SAFE_LUCAS,"FLOAT64_MAX_SAFE_LUCAS\n"
+FLOAT64_MAX_SAFE_NTH_FIBONACCI,"FLOAT64_MAX_SAFE_NTH_FIBONACCI\n"
+FLOAT64_MAX_SAFE_NTH_LUCAS,"FLOAT64_MAX_SAFE_NTH_LUCAS\n"
+FLOAT64_MIN_BASE2_EXPONENT,"FLOAT64_MIN_BASE2_EXPONENT\n"
+FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL,"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL\n"
+FLOAT64_MIN_BASE10_EXPONENT,"FLOAT64_MIN_BASE10_EXPONENT\n"
+FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL,"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL\n"
+FLOAT64_MIN_LN,"FLOAT64_MIN_LN\n"
+FLOAT64_MIN_SAFE_INTEGER,"FLOAT64_MIN_SAFE_INTEGER\n"
+FLOAT64_NUM_BYTES,"FLOAT64_NUM_BYTES\n"
+FLOAT64_PRECISION,"FLOAT64_PRECISION\n"
+FLOAT64_SMALLEST_NORMAL,"FLOAT64_SMALLEST_NORMAL\n"
+FLOAT64_SMALLEST_SUBNORMAL,"FLOAT64_SMALLEST_SUBNORMAL\n"
+Float64Array,"var arr = new Float64Array()\n"
+forEach,"function logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4 ];\nforEach( arr, logger )\n"
+forEachAsync,"\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n"
+forEachRight,"function logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4 ];\nforEachRight( arr, logger )\n"
+forEachRightAsync,"\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n"
+forIn,"function logger( v, k ) { console.log( '%s: %d', k, v ); };\nfunction Foo() { return this; };\nFoo.prototype.beep = 'boop';\nvar obj = new Foo();\nforIn( obj, logger )\n"
+forOwn,"function logger( v, k ) { console.log( '%s: %d', k, v ); };\nvar obj = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 };\nforOwn( obj, logger )\n"
+FOURTH_PI,"FOURTH_PI\n"
+FOURTH_ROOT_EPS,"FOURTH_ROOT_EPS\n"
+FRB_SF_WAGE_RIGIDITY,"var data = FRB_SF_WAGE_RIGIDITY()\n"
+fromCodePoint,"var out = fromCodePoint( 9731 )\nout = fromCodePoint( [ 9731 ] )\nout = fromCodePoint( 97, 98, 99 )\nout = fromCodePoint( [ 97, 98, 99 ] )\n"
+functionName,"var v = functionName( String )\nv = functionName( function foo(){} )\nv = functionName( function(){} )\n"
+functionSequence,"function a( x ) { return 2 * x; };\nfunction b( x ) { return x + 3; };\nfunction c( x ) { return x / 5; };\nvar f = functionSequence( a, b, c );\nvar z = f( 6 )\n"
+functionSequenceAsync,"function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nvar f = functionSequenceAsync( a, b, c );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n"
+GAMMA_LANCZOS_G,"GAMMA_LANCZOS_G\n"
+getegid,"var gid = getegid()\n"
+geteuid,"var uid = geteuid()\n"
+getgid,"var gid = getgid()\n"
+getGlobal,"var g = getGlobal()\n"
+getPrototypeOf,"var proto = getPrototypeOf( {} )\n"
+getuid,"var uid = getuid()\n"
+GLAISHER,"GLAISHER\n"
+group,"var collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar groups = [ 'b', 'b', 'f', 'b' ];\nvar out = group( collection, groups )\ngroups = [ 1, 1, 2, 1 ];\nout = group( collection, groups )\n\n// Output group results as indices:\ngroups = [ 'b', 'b', 'f', 'b' ];\nvar opts = { 'returns': 'indices' };\nout = group( collection, opts, groups )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = group( collection, opts, groups )\n"
+groupBy,"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = groupBy( collection, indicator )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nout = groupBy( collection, opts, indicator )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = groupBy( collection, opts, indicator )\n"
+groupByAsync,"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, indicator, done )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n"
+groupIn,"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nfunction Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nvar obj = new Foo();\nvar out = groupIn( obj, indicator )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = groupIn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupIn( obj, opts, indicator )\n"
+groupOwn,"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar obj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nvar out = groupOwn( obj, indicator )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = groupOwn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupOwn( obj, opts, indicator )\n"
+HALF_LN2,"HALF_LN2\n"
+HALF_PI,"HALF_PI\n"
+HARRISON_BOSTON_HOUSE_PRICES,"var data = HARRISON_BOSTON_HOUSE_PRICES()\n"
+HARRISON_BOSTON_HOUSE_PRICES_CORRECTED,"var data = HARRISON_BOSTON_HOUSE_PRICES_CORRECTED()\n"
+hasArrayBufferSupport,"var bool = hasArrayBufferSupport()\n"
+hasAsyncAwaitSupport,"var bool = hasAsyncAwaitSupport()\n"
+hasAsyncIteratorSymbolSupport,"var bool = hasAsyncIteratorSymbolSupport()\n"
+hasClassSupport,"var bool = hasClassSupport()\n"
+hasDefinePropertiesSupport,"var bool = hasDefinePropertiesSupport()\n"
+hasDefinePropertySupport,"var bool = hasDefinePropertySupport()\n"
+hasFloat32ArraySupport,"var bool = hasFloat32ArraySupport()\n"
+hasFloat64ArraySupport,"var bool = hasFloat64ArraySupport()\n"
+hasFunctionNameSupport,"var bool = hasFunctionNameSupport()\n"
+hasGeneratorSupport,"var bool = hasGeneratorSupport()\n"
+hasInt8ArraySupport,"var bool = hasInt8ArraySupport()\n"
+hasInt16ArraySupport,"var bool = hasInt16ArraySupport()\n"
+hasInt32ArraySupport,"var bool = hasInt32ArraySupport()\n"
+hasIteratorSymbolSupport,"var bool = hasIteratorSymbolSupport()\n"
+hasMapSupport,"var bool = hasMapSupport()\n"
+hasNodeBufferSupport,"var bool = hasNodeBufferSupport()\n"
+hasOwnProp,"var beep = { 'boop': true };\nvar bool = hasOwnProp( beep, 'boop' )\nbool = hasOwnProp( beep, 'bop' )\n"
+hasProp,"var beep = { 'boop': true };\nvar bool = hasProp( beep, 'boop' )\nbool = hasProp( beep, 'toString' )\nbool = hasProp( beep, 'bop' )\n"
+hasProxySupport,"var bool = hasProxySupport()\n"
+hasSetSupport,"var bool = hasSetSupport()\n"
+hasSharedArrayBufferSupport,"var bool = hasSharedArrayBufferSupport()\n"
+hasSymbolSupport,"var bool = hasSymbolSupport()\n"
+hasToStringTagSupport,"var bool = hasToStringTagSupport()\n"
+hasUint8ArraySupport,"var bool = hasUint8ArraySupport()\n"
+hasUint8ClampedArraySupport,"var bool = hasUint8ClampedArraySupport()\n"
+hasUint16ArraySupport,"var bool = hasUint16ArraySupport()\n"
+hasUint32ArraySupport,"var bool = hasUint32ArraySupport()\n"
+hasWeakMapSupport,"var bool = hasWeakMapSupport()\n"
+hasWeakSetSupport,"var bool = hasWeakSetSupport()\n"
+hasWebAssemblySupport,"var bool = hasWebAssemblySupport()\n"
+HERNDON_VENUS_SEMIDIAMETERS,"var d = HERNDON_VENUS_SEMIDIAMETERS()\n"
+homedir,"var home = homedir()\n"
+HOURS_IN_DAY,"var days = 3.14;\nvar hrs = days * HOURS_IN_DAY\n"
+HOURS_IN_WEEK,"var wks = 3.14;\nvar hrs = wks * HOURS_IN_WEEK\n"
+hoursInMonth,"var num = hoursInMonth()\nnum = hoursInMonth( 2 )\nnum = hoursInMonth( 2, 2016 )\nnum = hoursInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = hoursInMonth( 'feb', 2016 )\nnum = hoursInMonth( 'february', 2016 )\n"
+hoursInYear,"var num = hoursInYear()\nnum = hoursInYear( 2016 )\nnum = hoursInYear( 2017 )\n"
+httpServer,"\n// Basic usage:\nvar createServer = httpServer()\n\n// Provide a request callback:\nfunction onRequest( request, response ) {\n console.log( request.url );\n response.end( 'OK' );\n};\ncreateServer = httpServer( onRequest )\n\n// Specify a specific port:\nvar opts = { 'port': 7331 };\ncreateServer = httpServer( opts )\n"
+identity,"var v = identity( 3.14 )\n"
+ifelse,"var z = ifelse( true, 1.0, -1.0 )\nz = ifelse( false, 1.0, -1.0 )\n"
+ifelseAsync,"function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, true );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifelseAsync( predicate, 'beep', 'boop', done )\n"
+ifthen,"function x() { return 1.0; };\nfunction y() { return -1.0; };\nvar z = ifthen( true, x, y )\nz = ifthen( false, x, y )\n"
+ifthenAsync,"function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, false );\n }\n};\nfunction x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'beep' );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifthenAsync( predicate, x, y, done )\n"
+imag,"var z = new Complex128( 5.0, 3.0 );\nvar im = imag( z )\n"
+IMG_ACANTHUS_MOLLIS,"var img = IMG_ACANTHUS_MOLLIS()\n"
+IMG_AIRPLANE_FROM_ABOVE,"var img = IMG_AIRPLANE_FROM_ABOVE()\n"
+IMG_ALLIUM_OREOPHILUM,"var img = IMG_ALLIUM_OREOPHILUM()\n"
+IMG_BLACK_CANYON,"var img = IMG_BLACK_CANYON()\n"
+IMG_DUST_BOWL_HOME,"var img = IMG_DUST_BOWL_HOME()\n"
+IMG_FRENCH_ALPINE_LANDSCAPE,"var img = IMG_FRENCH_ALPINE_LANDSCAPE()\n"
+IMG_LOCOMOTION_HOUSE_CAT,"var img = IMG_LOCOMOTION_HOUSE_CAT()\n"
+IMG_LOCOMOTION_NUDE_MALE,"var img = IMG_LOCOMOTION_NUDE_MALE()\n"
+IMG_MARCH_PASTORAL,"var img = IMG_MARCH_PASTORAL()\n"
+IMG_NAGASAKI_BOATS,"var img = IMG_NAGASAKI_BOATS()\n"
+incrapcorr,"var accumulator = incrapcorr();\nvar ar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator()\n"
+incrcount,"var accumulator = incrcount();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n"
+incrcovariance,"var accumulator = incrcovariance();\nvar v = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator()\n"
+incrcovmat,"var accumulator = incrcovmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n"
+incrcv,"var accumulator = incrcv();\nvar cv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator()\n"
+increwmean,"var accumulator = increwmean( 0.5 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n"
+increwstdev,"var accumulator = increwstdev( 0.5 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+increwvariance,"var accumulator = increwvariance( 0.5 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n"
+incrgmean,"var accumulator = incrgmean();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrgrubbs,"var acc = incrgrubbs();\nvar res = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n"
+incrhmean,"var accumulator = incrhmean();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrkmeans,"var accumulator = incrkmeans( 5, 2 );\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v );\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v );\n"
+incrkurtosis,"var accumulator = incrkurtosis();\nvar v = accumulator( 2.0 )\nv = accumulator( 2.0 )\nv = accumulator( -4.0 )\nv = accumulator( -4.0 )\n"
+incrmaape,"var accumulator = incrmaape();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n"
+incrmae,"var accumulator = incrmae();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n"
+incrmapcorr,"var accumulator = incrmapcorr( 3 );\nvar ar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator( 3.0, -1.0 )\nar = accumulator( 5.0, -9.5 )\nar = accumulator()\n"
+incrmape,"var accumulator = incrmape();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n"
+incrmax,"var accumulator = incrmax();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n"
+incrmaxabs,"var accumulator = incrmaxabs();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n"
+incrmcovariance,"var accumulator = incrmcovariance( 3 );\nvar v = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator( 3.0, -1.0 )\nv = accumulator( 5.0, -9.5 )\nv = accumulator()\n"
+incrmcv,"var accumulator = incrmcv( 3 );\nvar cv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator( 3.0 )\ncv = accumulator( 7.0 )\ncv = accumulator()\n"
+incrmda,"var accumulator = incrmda();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 4.0 )\nm = accumulator()\n"
+incrme,"var accumulator = incrme();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n"
+incrmean,"var accumulator = incrmean();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n"
+incrmeanabs,"var accumulator = incrmeanabs();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n"
+incrmeanabs2,"var accumulator = incrmeanabs2();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n"
+incrmeanstdev,"var accumulator = incrmeanstdev();\nvar ms = accumulator()\nms = accumulator( 2.0 )\nms = accumulator( -5.0 )\nms = accumulator( 3.0 )\nms = accumulator( 5.0 )\nms = accumulator()\n"
+incrmeanvar,"var accumulator = incrmeanvar();\nvar mv = accumulator()\nmv = accumulator( 2.0 )\nmv = accumulator( -5.0 )\nmv = accumulator( 3.0 )\nmv = accumulator( 5.0 )\nmv = accumulator()\n"
+incrmgmean,"var accumulator = incrmgmean( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrmgrubbs,"var acc = incrmgrubbs( 20 );\nvar res = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n"
+incrmhmean,"var accumulator = incrmhmean( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrmidrange,"var accumulator = incrmidrange();\nvar v = accumulator()\nv = accumulator( 3.14 )\nv = accumulator( -5.0 )\nv = accumulator( 10.1 )\nv = accumulator()\n"
+incrmin,"var accumulator = incrmin();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n"
+incrminabs,"var accumulator = incrminabs();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n"
+incrminmax,"var accumulator = incrminmax();\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n"
+incrminmaxabs,"var accumulator = incrminmaxabs();\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n"
+incrmmaape,"var accumulator = incrmmaape( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n"
+incrmmae,"var accumulator = incrmmae( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n"
+incrmmape,"var accumulator = incrmmape( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n"
+incrmmax,"var accumulator = incrmmax( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n"
+incrmmaxabs,"var accumulator = incrmmaxabs( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n"
+incrmmda,"var accumulator = incrmmda( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 4.0, 5.0 )\nm = accumulator()\n"
+incrmme,"var accumulator = incrmme( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n"
+incrmmean,"var accumulator = incrmmean( 3 );\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n"
+incrmmeanabs,"var accumulator = incrmmeanabs( 3 );\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n"
+incrmmeanabs2,"var accumulator = incrmmeanabs2( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n"
+incrmmeanstdev,"var accumulator = incrmmeanstdev( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrmmeanvar,"var accumulator = incrmmeanvar( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n"
+incrmmidrange,"var accumulator = incrmmidrange( 3 );\nvar mr = accumulator()\nmr = accumulator( 2.0 )\nmr = accumulator( -5.0 )\nmr = accumulator( 3.0 )\nmr = accumulator( 5.0 )\nmr = accumulator()\n"
+incrmmin,"var accumulator = incrmmin( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n"
+incrmminabs,"var accumulator = incrmminabs( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n"
+incrmminmax,"var accumulator = incrmminmax( 3 );\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n"
+incrmminmaxabs,"var accumulator = incrmminmaxabs( 3 );\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n"
+incrmmpe,"var accumulator = incrmmpe( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n"
+incrmmse,"var accumulator = incrmmse( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n"
+incrmpcorr,"var accumulator = incrmpcorr( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator( 3.0, -1.0 )\nr = accumulator( 5.0, -9.5 )\nr = accumulator()\n"
+incrmpcorr2,"var accumulator = incrmpcorr2( 3 );\nvar r2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator( 3.0, -1.0 )\nr2 = accumulator( 5.0, -9.5 )\nr2 = accumulator()\n"
+incrmpcorrdist,"var accumulator = incrmpcorrdist( 3 );\nvar d = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator( 3.0, -1.0 )\nd = accumulator( 5.0, -9.5 )\nd = accumulator()\n"
+incrmpe,"var accumulator = incrmpe();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n"
+incrmprod,"var accumulator = incrmprod( 3 );\nvar p = accumulator()\np = accumulator( 2.0 )\np = accumulator( -5.0 )\np = accumulator( 3.0 )\np = accumulator( 5.0 )\np = accumulator()\n"
+incrmrange,"var accumulator = incrmrange( 3 );\nvar r = accumulator()\nr = accumulator( 2.0 )\nr = accumulator( -5.0 )\nr = accumulator( 3.0 )\nr = accumulator( 5.0 )\nr = accumulator()\n"
+incrmrmse,"var accumulator = incrmrmse( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n"
+incrmrss,"var accumulator = incrmrss( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n"
+incrmse,"var accumulator = incrmse();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n"
+incrmstdev,"var accumulator = incrmstdev( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n"
+incrmsum,"var accumulator = incrmsum( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n"
+incrmsumabs,"var accumulator = incrmsumabs( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrmsumabs2,"var accumulator = incrmsumabs2( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrmsummary,"var accumulator = incrmsummary( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrmsumprod,"var accumulator = incrmsumprod( 3 );\nvar s = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator( 3.0, -2.0 )\ns = accumulator( 5.0, 3.0 )\ns = accumulator()\n"
+incrmvariance,"var accumulator = incrmvariance( 3 );\nvar s2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator( 3.0 )\ns2 = accumulator( 5.0 )\ns2 = accumulator()\n"
+incrmvmr,"var accumulator = incrmvmr( 3 );\nvar F = accumulator()\nF = accumulator( 2.0 )\nF = accumulator( 1.0 )\nF = accumulator( 3.0 )\nF = accumulator( 7.0 )\nF = accumulator()\n"
+incrpcorr,"var accumulator = incrpcorr();\nvar r = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator()\n"
+incrpcorr2,"var accumulator = incrpcorr2();\nvar r2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator()\n"
+incrpcorrdist,"var accumulator = incrpcorrdist();\nvar d = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator()\n"
+incrpcorrdistmat,"var accumulator = incrpcorrdistmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n"
+incrpcorrmat,"var accumulator = incrpcorrmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n"
+incrprod,"var accumulator = incrprod();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n"
+incrrange,"var accumulator = incrrange();\nvar v = accumulator()\nv = accumulator( -2.0 )\nv = accumulator( 1.0 )\nv = accumulator( 3.0 )\nv = accumulator()\n"
+incrrmse,"var accumulator = incrrmse();\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n"
+incrrss,"var accumulator = incrrss();\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n"
+incrskewness,"var accumulator = incrskewness();\nvar v = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( -10.0 )\nv = accumulator()\n"
+incrspace,"var arr = incrspace( 0, 11, 2 )\n"
+incrstdev,"var accumulator = incrstdev();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrsum,"var accumulator = incrsum();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrsumabs,"var accumulator = incrsumabs();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrsumabs2,"var accumulator = incrsumabs2();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrsummary,"var accumulator = incrsummary();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n"
+incrsumprod,"var accumulator = incrsumprod();\nvar s = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator()\n"
+incrvariance,"var accumulator = incrvariance();\nvar s2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator()\n"
+incrvmr,"var accumulator = incrvmr();\nvar D = accumulator()\nD = accumulator( 2.0 )\nD = accumulator( 1.0 )\nD = accumulator()\n"
+incrwmean,"var accumulator = incrwmean();\nvar mu = accumulator()\nmu = accumulator( 2.0, 1.0 )\nmu = accumulator( 2.0, 0.5 )\nmu = accumulator( 3.0, 1.5 )\nmu = accumulator()\n"
+ind2sub,"var d = [ 3, 3, 3 ];\nvar s = ind2sub( d, 17 )\n\n// Provide an output array:\nvar out = new Array( d.length );\ns = ind2sub( out, d, 17 )\nvar bool = ( s === out )\n"
+indexOf,"\n// Basic usage:\nvar arr = [ 4, 3, 2, 1 ];\nvar idx = indexOf( arr, 3 )\narr = [ 4, 3, 2, 1 ];\nidx = indexOf( arr, 5 )\n\n// Using a `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, 3 )\n\n// `fromIndex` which exceeds `array` length:\narr = [ 1, 2, 3, 4, 2, 5 ];\nidx = indexOf( arr, 2, 10 )\n\n// Negative `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6, 2 ];\nidx = indexOf( arr, 2, -4 )\nidx = indexOf( arr, 2, -1 )\n\n// Negative `fromIndex` exceeding input `array` length:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, -10 )\n\n// Array-like objects:\nvar str = 'bebop';\nidx = indexOf( str, 'o' )\n"
+inherit,"\n// Create a parent constructor:\nfunction Foo() { return this; };\nFoo.prototype.beep = function beep() { return 'boop'; };\n\n// Create a child constructor:\nfunction Bar() { Foo.call( this ); return this; };\n\n// Setup inheritance:\ninherit( Bar, Foo );\nvar bar = new Bar();\nvar v = bar.beep()\n"
+inheritedEnumerableProperties,"var props = inheritedEnumerableProperties( {} )\n"
+inheritedEnumerablePropertySymbols,"var symbols = inheritedEnumerablePropertySymbols( [] )\n"
+inheritedKeys,"var keys = inheritedKeys( {} )\n"
+inheritedNonEnumerableProperties,"var props = inheritedNonEnumerableProperties( {} )\n"
+inheritedNonEnumerablePropertyNames,"var keys = inheritedNonEnumerablePropertyNames( {} )\n"
+inheritedNonEnumerablePropertySymbols,"var symbols = inheritedNonEnumerablePropertySymbols( [] )\n"
+inheritedProperties,"var symbols = inheritedProperties( [] )\n"
+inheritedPropertyDescriptor,"var desc = inheritedPropertyDescriptor( {}, 'toString' )\n"
+inheritedPropertyDescriptors,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar desc = inheritedPropertyDescriptors( obj )\n"
+inheritedPropertyNames,"var keys = inheritedPropertyNames( [] )\n"
+inheritedPropertySymbols,"var symbols = inheritedPropertySymbols( [] )\n"
+inheritedWritableProperties,"var props = inheritedWritableProperties( {} )\n"
+inheritedWritablePropertyNames,"var keys = inheritedWritablePropertyNames( {} )\n"
+inheritedWritablePropertySymbols,"var symbols = inheritedWritablePropertySymbols( [] )\n"
+inmap,"function foo( v, i ) { return v * i; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = inmap( arr, foo )\nvar bool = ( out === arr )\n"
+inmapAsync,"\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n"
+inmapRight,"function foo( v, i ) { console.log( '%s: %d', i, v ); return v * i; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = inmapRight( arr, foo )\nvar bool = ( out === arr )\n"
+inmapRightAsync,"\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n"
+inspectSinkStream,"function clbk( chunk, idx ) { console.log( chunk.toString() ); };\nvar s = inspectSinkStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+inspectStream,"function clbk( chunk, idx ) { console.log( chunk.toString() ); };\nvar s = inspectStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+instanceOf,"var bool = instanceOf( [], Array )\nbool = instanceOf( {}, Object )\nbool = instanceOf( null, Object )\n"
+INT8_MAX,"INT8_MAX\n"
+INT8_MIN,"INT8_MIN\n"
+INT8_NUM_BYTES,"INT8_NUM_BYTES\n"
+Int8Array,"var arr = new Int8Array()\n"
+INT16_MAX,"INT16_MAX\n"
+INT16_MIN,"INT16_MIN\n"
+INT16_NUM_BYTES,"INT16_NUM_BYTES\n"
+Int16Array,"var arr = new Int16Array()\n"
+INT32_MAX,"INT32_MAX\n"
+INT32_MIN,"INT32_MIN\n"
+INT32_NUM_BYTES,"INT32_NUM_BYTES\n"
+Int32Array,"var arr = new Int32Array()\n"
+IS_BIG_ENDIAN,"IS_BIG_ENDIAN\n"
+IS_BROWSER,"IS_BROWSER\n"
+IS_DARWIN,"IS_DARWIN\n"
+IS_ELECTRON,"IS_ELECTRON\n"
+IS_ELECTRON_MAIN,"IS_ELECTRON_MAIN\n"
+IS_ELECTRON_RENDERER,"IS_ELECTRON_RENDERER\n"
+IS_LITTLE_ENDIAN,"IS_LITTLE_ENDIAN\n"
+IS_NODE,"IS_NODE\n"
+IS_WEB_WORKER,"IS_WEB_WORKER\n"
+IS_WINDOWS,"IS_WINDOWS\n"
+isAbsolutePath,"\n// Windows environment:\nvar bool = isAbsolutePath( 'C:\\foo\\bar\\baz' )\n\n// POSIX environment:\nbool = isAbsolutePath( '/foo/bar/baz' )\n"
+isAccessorProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isAccessorProperty( obj, 'boop' )\nbool = isAccessorProperty( obj, 'beep' )\n"
+isAccessorPropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isAccessorPropertyIn( obj, 'boop' )\nbool = isAccessorPropertyIn( obj, 'beep' )\n"
+isAlphagram,"var out = isAlphagram( 'beep' )\nout = isAlphagram( 'zba' )\nout = isAlphagram( '' )\n"
+isAlphaNumeric,"var bool = isAlphaNumeric( 'abc0123456789' )\nbool = isAlphaNumeric( 'abcdef' )\nbool = isAlphaNumeric( '0xff' )\nbool = isAlphaNumeric( '' )\n"
+isAnagram,"var str1 = 'I am a weakish speller';\nvar str2 = 'William Shakespeare';\nvar bool = isAnagram( str1, str2 )\nbool = isAnagram( 'bat', 'tabba' )\n"
+isArguments,"function foo() { return arguments; };\nvar bool = isArguments( foo() )\nbool = isArguments( [] )\n"
+isArray,"var bool = isArray( [] )\nbool = isArray( {} )\n"
+isArrayArray,"var bool = isArrayArray( [ [], [] ] )\nbool = isArrayArray( [ {}, {} ] )\nbool = isArrayArray( [] )\n"
+isArrayBuffer,"var bool = isArrayBuffer( new ArrayBuffer( 10 ) )\nbool = isArrayBuffer( [] )\n"
+isArrayLength,"var bool = isArrayLength( 5 )\nbool = isArrayLength( 2.0e200 )\nbool = isArrayLength( -3.14 )\nbool = isArrayLength( null )\n"
+isArrayLike,"var bool = isArrayLike( [] )\nbool = isArrayLike( { 'length': 10 } )\nbool = isArrayLike( 'beep' )\nbool = isArrayLike( null )\n"
+isArrayLikeObject,"var bool = isArrayLikeObject( [] )\nbool = isArrayLikeObject( { 'length': 10 } )\nbool = isArrayLikeObject( 'beep' )\n"
+isASCII,"var str = 'beep boop';\nvar bool = isASCII( str )\nbool = isASCII( fromCodePoint( 130 ) )\n"
+isBetween,"var bool = isBetween( 3.14, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.0, 4.0 )\nbool = isBetween( 4.0, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.14, 4.0 )\nbool = isBetween( 3.14, 3.14, 4.0, 'open', 'closed' )\nbool = isBetween( 3.14, 3.0, 3.14, 'closed', 'open' )\n"
+isBetweenArray,"var arr = [ 3.0, 3.14, 4.0 ];\nvar bool = isBetweenArray( arr, 3.0, 4.0 )\nbool = isBetweenArray( arr, 3.14, 4.0 )\nbool = isBetweenArray( arr, 3.0, 3.14 )\nbool = isBetweenArray( arr, 3.0, 4.0, 'open', 'closed' )\nbool = isBetweenArray( arr, 3.0, 4.0, 'closed', 'open' )\n"
+isBinaryString,"var bool = isBinaryString( '1000101' )\nbool = isBinaryString( 'beep' )\nbool = isBinaryString( '' )\n"
+isBoolean,"var bool = isBoolean( false )\nbool = isBoolean( new Boolean( false ) )\n"
+isBooleanArray,"var bool = isBooleanArray( [ true, false, true ] )\nbool = isBooleanArray( [ true, 'abc', false ] )\n"
+isBoxedPrimitive,"var bool = isBoxedPrimitive( new Boolean( false ) )\nbool = isBoxedPrimitive( true )\n"
+isBuffer,"var bool = isBuffer( new Buffer( 'beep' ) )\nbool = isBuffer( new Buffer( [ 1, 2, 3, 4 ] ) )\nbool = isBuffer( {} )\nbool = isBuffer( [] )\n"
+isCapitalized,"var bool = isCapitalized( 'Hello' )\nbool = isCapitalized( 'world' )\n"
+isCentrosymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 2, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isCentrosymmetricMatrix( M )\nbool = isCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isCentrosymmetricMatrix( 3.14 )\nbool = isCentrosymmetricMatrix( {} )\n"
+isCircular,"var obj = { 'beep': 'boop' };\nobj.self = obj;\nvar bool = isCircular( obj )\nbool = isCircular( {} )\nbool = isCircular( null )\n"
+isCircularArray,"var arr = [ 1, 2, 3 ];\narr.push( arr );\nvar bool = isCircularArray( arr )\nbool = isCircularArray( [] )\nbool = isCircularArray( null )\n"
+isCircularPlainObject,"var obj = { 'beep': 'boop' };\nobj.self = obj;\nvar bool = isCircularPlainObject( obj )\nbool = isCircularPlainObject( {} )\nbool = isCircularPlainObject( null )\n"
+isCollection,"var bool = isCollection( [] )\nbool = isCollection( { 'length': 0 } )\nbool = isCollection( {} )\n"
+isComplex,"var bool = isComplex( new Complex64( 2.0, 2.0 ) )\nbool = isComplex( new Complex128( 3.0, 1.0 ) )\nbool = isComplex( 3.14 )\nbool = isComplex( {} )\n"
+isComplex64,"var bool = isComplex64( new Complex64( 2.0, 2.0 ) )\nbool = isComplex64( new Complex128( 3.0, 1.0 ) )\nbool = isComplex64( 3.14 )\nbool = isComplex64( {} )\n"
+isComplex64Array,"var bool = isComplex64Array( new Complex64Array( 10 ) )\nbool = isComplex64Array( [] )\n"
+isComplex128,"var bool = isComplex128( new Complex128( 3.0, 1.0 ) )\nbool = isComplex128( new Complex64( 2.0, 2.0 ) )\nbool = isComplex128( 3.14 )\nbool = isComplex128( {} )\n"
+isComplex128Array,"var bool = isComplex128Array( new Complex128Array( 10 ) )\nbool = isComplex128Array( [] )\n"
+isComplexLike,"var bool = isComplexLike( new Complex64( 2.0, 2.0 ) )\nbool = isComplexLike( new Complex128( 3.0, 1.0 ) )\nbool = isComplexLike( 3.14 )\nbool = isComplexLike( {} )\n"
+isComplexTypedArray,"var bool = isComplexTypedArray( new Complex64Array( 10 ) )\n"
+isConfigurableProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isConfigurableProperty( obj, 'boop' )\nbool = isConfigurableProperty( obj, 'beep' )\n"
+isConfigurablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isConfigurablePropertyIn( obj, 'boop' )\nbool = isConfigurablePropertyIn( obj, 'beep' )\n"
+isDataProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isDataProperty( obj, 'boop' )\nbool = isDataProperty( obj, 'beep' )\n"
+isDataPropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isDataPropertyIn( obj, 'boop' )\nbool = isDataPropertyIn( obj, 'beep' )\n"
+isDateObject,"var bool = isDateObject( new Date() )\nbool = isDateObject( '2017-01-01' )\n"
+isDigitString,"var bool = isDigitString( '0123456789' )\nbool = isDigitString( 'abcdef' )\nbool = isDigitString( '0xff' )\nbool = isDigitString( '' )\n"
+isEmailAddress,"var bool = isEmailAddress( 'beep@boop.com' )\nbool = isEmailAddress( 'beep' )\nbool = isEmailAddress( null )\n"
+isEmptyArray,"var bool = isEmptyArray( [] )\nbool = isEmptyArray( [ 1, 2, 3 ] )\nbool = isEmptyArray( {} )\n"
+isEmptyObject,"var bool = isEmptyObject( {} )\nbool = isEmptyObject( { 'beep': 'boop' } )\nbool = isEmptyObject( [] )\n"
+isEmptyString,"var bool = isEmptyString( '' )\nbool = isEmptyString( new String( '' ) )\nbool = isEmptyString( 'beep' )\nbool = isEmptyString( [] )\n"
+isEnumerableProperty,"var beep = { 'boop': true };\nvar bool = isEnumerableProperty( beep, 'boop' )\nbool = isEnumerableProperty( beep, 'hasOwnProperty' )\n"
+isEnumerablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isEnumerablePropertyIn( obj, 'boop' )\nbool = isEnumerablePropertyIn( obj, 'beep' )\n"
+isError,"var bool = isError( new Error( 'beep' ) )\nbool = isError( {} )\n"
+isEvalError,"var bool = isEvalError( new EvalError( 'beep' ) )\nbool = isEvalError( {} )\n"
+isEven,"var bool = isEven( 4.0 )\nbool = isEven( new Number( 4.0 ) )\nbool = isEven( 3.0 )\nbool = isEven( -3.14 )\nbool = isEven( null )\n"
+isFalsy,"var bool = isFalsy( false )\nbool = isFalsy( '' )\nbool = isFalsy( 0 )\nbool = isFalsy( null )\nbool = isFalsy( void 0 )\nbool = isFalsy( NaN )\nbool = isFalsy( {} )\nbool = isFalsy( [] )\n"
+isFalsyArray,"var bool = isFalsyArray( [ null, '' ] )\nbool = isFalsyArray( [ {}, [] ] )\nbool = isFalsyArray( [] )\n"
+isFinite,"var bool = isFinite( 5.0 )\nbool = isFinite( new Number( 5.0 ) )\nbool = isFinite( 1.0/0.0 )\nbool = isFinite( null )\n"
+isFiniteArray,"var bool = isFiniteArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isFiniteArray( [ -3.0, 1.0/0.0 ] )\n"
+isFloat32Array,"var bool = isFloat32Array( new Float32Array( 10 ) )\nbool = isFloat32Array( [] )\n"
+isFloat64Array,"var bool = isFloat64Array( new Float64Array( 10 ) )\nbool = isFloat64Array( [] )\n"
+isFunction,"function beep() {};\nvar bool = isFunction( beep )\nbool = isFunction( {} )\n"
+isFunctionArray,"function beep() {};\nfunction boop() {};\nvar bool = isFunctionArray( [ beep, boop ] )\nbool = isFunctionArray( [ {}, beep ] )\nbool = isFunctionArray( [] )\n"
+isGeneratorObject,"function* generateID() {\n var idx = 0;\n while ( idx < idx+1 ) {\n yield idx;\n idx += 1;\n }\n};\nvar bool = isGeneratorObject( generateID() )\nbool = isGeneratorObject( generateID )\nbool = isGeneratorObject( {} )\nbool = isGeneratorObject( null )\n"
+isGeneratorObjectLike,"var obj = {\n 'next': function noop() {},\n 'return': function noop() {},\n 'throw': function noop() {}\n};\nvar bool = isGeneratorObjectLike( obj )\nbool = isGeneratorObjectLike( {} )\nbool = isGeneratorObjectLike( null )\n"
+isHexString,"var bool = isHexString( '0123456789abcdefABCDEF' )\nbool = isHexString( '0xffffff' )\nbool = isHexString( 'x' )\nbool = isHexString( '' )\n"
+isInfinite,"var bool = isInfinite( 1.0/0.0 )\nbool = isInfinite( new Number( -1.0/0.0 ) )\nbool = isInfinite( 5.0 )\nbool = isInfinite( '1.0/0.0' )\n"
+isInheritedProperty,"var beep = { 'boop': true };\nvar bool = isInheritedProperty( beep, 'boop' )\nbool = isInheritedProperty( beep, 'toString' )\nbool = isInheritedProperty( beep, 'bop' )\n"
+isInt8Array,"var bool = isInt8Array( new Int8Array( 10 ) )\nbool = isInt8Array( [] )\n"
+isInt16Array,"var bool = isInt16Array( new Int16Array( 10 ) )\nbool = isInt16Array( [] )\n"
+isInt32Array,"var bool = isInt32Array( new Int32Array( 10 ) )\nbool = isInt32Array( [] )\n"
+isInteger,"var bool = isInteger( 5.0 )\nbool = isInteger( new Number( 5.0 ) )\nbool = isInteger( -3.14 )\nbool = isInteger( null )\n"
+isIntegerArray,"var bool = isIntegerArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isIntegerArray( [ -3.0, '3.0' ] )\n"
+isIterableLike,"var bool = isIterableLike( [ 1, 2, 3 ] )\nbool = isIterableLike( {} )\nbool = isIterableLike( null )\n"
+isIteratorLike,"var obj = {\n 'next': function noop() {}\n};\nvar bool = isIteratorLike( obj )\nbool = isIteratorLike( {} )\nbool = isIteratorLike( null )\n"
+isJSON,"var bool = isJSON( '{\"a\":5}' )\nbool = isJSON( '{a\":5}' )\n"
+isLeapYear,"var bool = isLeapYear( new Date() )\nbool = isLeapYear( 1996 )\nbool = isLeapYear( 2001 )\n"
+isLowercase,"var bool = isLowercase( 'hello' )\nbool = isLowercase( 'World' )\n"
+isMatrixLike,"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isMatrixLike( M )\nbool = isMatrixLike( [ 1, 2, 3, 4 ] )\nbool = isMatrixLike( 3.14 )\nbool = isMatrixLike( {} )\n"
+isMethod,"var beep = { 'boop': function beep() { return 'beep'; } };\nvar bool = isMethod( beep, 'boop' )\nbool = isMethod( beep, 'toString' )\n"
+isMethodIn,"var beep = { 'boop': true };\nvar bool = isMethodIn( beep, 'toString' )\nbool = isMethodIn( beep, 'boop' )\nbool = isMethodIn( beep, 'bop' )\n"
+isNamedTypedTupleLike,"var Point = namedtypedtuple( [ 'x', 'y' ] );\nvar p = new Point();\nvar bool = isNamedTypedTupleLike( p )\nbool = isNamedTypedTupleLike( [ 1, 2, 3, 4 ] )\nbool = isNamedTypedTupleLike( 3.14 )\nbool = isNamedTypedTupleLike( {} )\n"
+isnan,"var bool = isnan( NaN )\nbool = isnan( new Number( NaN ) )\nbool = isnan( 3.14 )\nbool = isnan( null )\n"
+isNaNArray,"var bool = isNaNArray( [ NaN, NaN, NaN ] )\nbool = isNaNArray( [ NaN, 2 ] )\n"
+isNativeFunction,"var bool = isNativeFunction( Date )\nfunction beep() {};\nbool = isNativeFunction( beep )\nbool = isNativeFunction( {} )\n"
+isndarrayLike,"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isndarrayLike( M )\nbool = isndarrayLike( [ 1, 2, 3, 4 ] )\nbool = isndarrayLike( 3.14 )\nbool = isndarrayLike( {} )\n"
+isNegativeInteger,"var bool = isNegativeInteger( -5.0 )\nbool = isNegativeInteger( new Number( -5.0 ) )\nbool = isNegativeInteger( 5.0 )\nbool = isNegativeInteger( -3.14 )\nbool = isNegativeInteger( null )\n"
+isNegativeIntegerArray,"var bool = isNegativeIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeIntegerArray( [ -3.0, '-3.0' ] )\n"
+isNegativeNumber,"var bool = isNegativeNumber( -5.0 )\nbool = isNegativeNumber( new Number( -5.0 ) )\nbool = isNegativeNumber( -3.14 )\nbool = isNegativeNumber( 5.0 )\nbool = isNegativeNumber( null )\n"
+isNegativeNumberArray,"var bool = isNegativeNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeNumberArray( [ -3.0, '-3.0' ] )\n"
+isNegativeZero,"var bool = isNegativeZero( -0.0 )\nbool = isNegativeZero( new Number( -0.0 ) )\nbool = isNegativeZero( -3.14 )\nbool = isNegativeZero( 0.0 )\nbool = isNegativeZero( null )\n"
+isNodeBuiltin,"var bool = isNodeBuiltin( 'cluster' )\nbool = isNodeBuiltin( 'crypto' )\nbool = isNodeBuiltin( 'fs-extra' )\nbool = isNodeBuiltin( '' )\n"
+isNodeDuplexStreamLike,"var Stream = require( 'stream' ).Duplex;\ns = new Stream();\nvar bool = isNodeDuplexStreamLike( s )\nbool = isNodeDuplexStreamLike( {} )\n"
+isNodeReadableStreamLike,"var Stream = require( 'stream' ).Readable;\ns = new Stream();\nvar bool = isNodeReadableStreamLike( s )\nbool = isNodeReadableStreamLike( {} )\n"
+isNodeREPL,"var bool = isNodeREPL()\n"
+isNodeStreamLike,"var Stream = require( 'stream' ).Stream;\ns = new Stream();\nvar bool = isNodeStreamLike( s )\nbool = isNodeStreamLike( {} )\n"
+isNodeTransformStreamLike,"var Stream = require( 'stream' ).Transform;\ns = new Stream();\nvar bool = isNodeTransformStreamLike( s )\nbool = isNodeTransformStreamLike( {} )\n"
+isNodeWritableStreamLike,"var Stream = require( 'stream' ).Writable;\ns = new Stream();\nvar bool = isNodeWritableStreamLike( s )\nbool = isNodeWritableStreamLike( {} )\n"
+isNonConfigurableProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonConfigurableProperty( obj, 'boop' )\nbool = isNonConfigurableProperty( obj, 'beep' )\n"
+isNonConfigurablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonConfigurablePropertyIn( obj, 'boop' )\nbool = isNonConfigurablePropertyIn( obj, 'beep' )\n"
+isNonEnumerableProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonEnumerableProperty( obj, 'boop' )\nbool = isNonEnumerableProperty( obj, 'beep' )\n"
+isNonEnumerablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonEnumerablePropertyIn( obj, 'boop' )\nbool = isNonEnumerablePropertyIn( obj, 'beep' )\n"
+isNonNegativeInteger,"var bool = isNonNegativeInteger( 5.0 )\nbool = isNonNegativeInteger( new Number( 5.0 ) )\nbool = isNonNegativeInteger( 3.14 )\nbool = isNonNegativeInteger( -5.0 )\nbool = isNonNegativeInteger( null )\n"
+isNonNegativeIntegerArray,"var bool = isNonNegativeIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeIntegerArray( [ 3.0, '3.0' ] )\n"
+isNonNegativeNumber,"var bool = isNonNegativeNumber( 5.0 )\nbool = isNonNegativeNumber( new Number( 5.0 ) )\nbool = isNonNegativeNumber( 3.14 )\nbool = isNonNegativeNumber( -5.0 )\nbool = isNonNegativeNumber( null )\n"
+isNonNegativeNumberArray,"var bool = isNonNegativeNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeNumberArray( [ 3.0, '3.0' ] )\n"
+isNonPositiveInteger,"var bool = isNonPositiveInteger( -5.0 )\nbool = isNonPositiveInteger( new Number( -5.0 ) )\nbool = isNonPositiveInteger( 5.0 )\nbool = isNonPositiveInteger( -3.14 )\nbool = isNonPositiveInteger( null )\n"
+isNonPositiveIntegerArray,"var bool = isNonPositiveIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveIntegerArray( [ -3.0, '-3.0' ] )\n"
+isNonPositiveNumber,"var bool = isNonPositiveNumber( -5.0 )\nbool = isNonPositiveNumber( new Number( -5.0 ) )\nbool = isNonPositiveNumber( -3.14 )\nbool = isNonPositiveNumber( 5.0 )\nbool = isNonPositiveNumber( null )\n"
+isNonPositiveNumberArray,"var bool = isNonPositiveNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveNumberArray( [ -3.0, '-3.0' ] )\n"
+isNonSymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isNonSymmetricMatrix( M )\nbool = isNonSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isNonSymmetricMatrix( 3.14 )\nbool = isNonSymmetricMatrix( {} )\n"
+isNull,"var bool = isNull( null )\nbool = isNull( true )\n"
+isNullArray,"var bool = isNullArray( [ null, null, null ] )\nbool = isNullArray( [ NaN, 2, null ] )\n"
+isNumber,"var bool = isNumber( 3.14 )\nbool = isNumber( new Number( 3.14 ) )\nbool = isNumber( NaN )\nbool = isNumber( null )\n"
+isNumberArray,"var bool = isNumberArray( [ 1, 2, 3 ] )\nbool = isNumberArray( [ '1', 2, 3 ] )\n"
+isNumericArray,"var bool = isNumericArray( new Int8Array( 10 ) )\nbool = isNumericArray( [ 1, 2, 3 ] )\nbool = isNumericArray( [ '1', '2', '3' ] )\n"
+isObject,"var bool = isObject( {} )\nbool = isObject( true )\n"
+isObjectArray,"var bool = isObjectArray( [ {}, new Number(3.0) ] )\nbool = isObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isObjectArray( [ {}, '3.0' ] )\n"
+isObjectLike,"var bool = isObjectLike( {} )\nbool = isObjectLike( [] )\nbool = isObjectLike( null )\n"
+isOdd,"var bool = isOdd( 5.0 )\nbool = isOdd( new Number( 5.0 ) )\nbool = isOdd( 4.0 )\nbool = isOdd( new Number( 4.0 ) )\nbool = isOdd( -3.14 )\nbool = isOdd( null )\n"
+isoWeeksInYear,"var num = isoWeeksInYear()\nnum = isoWeeksInYear( 2015 )\nnum = isoWeeksInYear( 2017 )\n"
+isPersymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 2, 3, 1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isPersymmetricMatrix( M )\nbool = isPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isPersymmetricMatrix( 3.14 )\nbool = isPersymmetricMatrix( {} )\n"
+isPlainObject,"var bool = isPlainObject( {} )\nbool = isPlainObject( null )\n"
+isPlainObjectArray,"var bool = isPlainObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isPlainObjectArray( [ {}, new Number(3.0) ] )\nbool = isPlainObjectArray( [ {}, '3.0' ] )\n"
+isPositiveInteger,"var bool = isPositiveInteger( 5.0 )\nbool = isPositiveInteger( new Number( 5.0 ) )\nbool = isPositiveInteger( 3.14 )\nbool = isPositiveInteger( -5.0 )\nbool = isPositiveInteger( null )\n"
+isPositiveIntegerArray,"var bool = isPositiveIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveIntegerArray( [ 3.0, '3.0' ] )\n"
+isPositiveNumber,"var bool = isPositiveNumber( 5.0 )\nbool = isPositiveNumber( new Number( 5.0 ) )\nbool = isPositiveNumber( 3.14 )\nbool = isPositiveNumber( -5.0 )\nbool = isPositiveNumber( null )\n"
+isPositiveNumberArray,"var bool = isPositiveNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveNumberArray( [ 3.0, '3.0' ] )\n"
+isPositiveZero,"var bool = isPositiveZero( 0.0 )\nbool = isPositiveZero( new Number( 0.0 ) )\nbool = isPositiveZero( -3.14 )\nbool = isPositiveZero( -0.0 )\nbool = isPositiveZero( null )\n"
+isPrimitive,"var bool = isPrimitive( true )\nbool = isPrimitive( {} )\n"
+isPrimitiveArray,"var bool = isPrimitiveArray( [ '3', 2, null ] )\nbool = isPrimitiveArray( [ {}, 2, 1 ] )\nbool = isPrimitiveArray( [ new String('abc'), '3.0' ] )\n"
+isPRNGLike,"var bool = isPRNGLike( base.random.randu )\nbool = isPRNGLike( [ 1, 2, 3, 4 ] )\nbool = isPRNGLike( 3.14 )\nbool = isPRNGLike( {} )\n"
+isProbability,"var bool = isProbability( 0.5 )\nbool = isProbability( new Number( 0.5 ) )\nbool = isProbability( 3.14 )\nbool = isProbability( -5.0 )\nbool = isProbability( null )\n"
+isProbabilityArray,"var bool = isProbabilityArray( [ 0.5, new Number(0.8) ] )\nbool = isProbabilityArray( [ 0.8, 1.2 ] )\nbool = isProbabilityArray( [ 0.8, '0.2' ] )\n"
+isPrototypeOf,"function Foo() { return this; };\nfunction Bar() { return this; };\ninherit( Bar, Foo );\nvar bar = new Bar();\nvar bool = isPrototypeOf( bar, Foo.prototype )\n"
+isRangeError,"var bool = isRangeError( new RangeError( 'beep' ) )\nbool = isRangeError( {} )\n"
+isReadableProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadableProperty( obj, 'boop' )\nbool = isReadableProperty( obj, 'beep' )\n"
+isReadablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadablePropertyIn( obj, 'boop' )\nbool = isReadablePropertyIn( obj, 'beep' )\n"
+isReadOnlyProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadOnlyProperty( obj, 'boop' )\nbool = isReadOnlyProperty( obj, 'beep' )\n"
+isReadOnlyPropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadOnlyPropertyIn( obj, 'boop' )\nbool = isReadOnlyPropertyIn( obj, 'beep' )\n"
+isReadWriteProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadWriteProperty( obj, 'boop' )\nbool = isReadWriteProperty( obj, 'beep' )\n"
+isReadWritePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadWritePropertyIn( obj, 'boop' )\nbool = isReadWritePropertyIn( obj, 'beep' )\n"
+isReferenceError,"var bool = isReferenceError( new ReferenceError( 'beep' ) )\nbool = isReferenceError( {} )\n"
+isRegExp,"var bool = isRegExp( /\.+/ )\nbool = isRegExp( {} )\n"
+isRegExpString,"var bool = isRegExpString( '/beep/' )\nbool = isRegExpString( 'beep' )\nbool = isRegExpString( '' )\nbool = isRegExpString( null )\n"
+isRelativePath,"\n// Windows environments:\nvar bool = isRelativePath( 'foo\\bar\\baz' )\n\n// POSIX environments:\nbool = isRelativePath( './foo/bar/baz' )\n"
+isSafeInteger,"var bool = isSafeInteger( 5.0 )\nbool = isSafeInteger( new Number( 5.0 ) )\nbool = isSafeInteger( 2.0e200 )\nbool = isSafeInteger( -3.14 )\nbool = isSafeInteger( null )\n"
+isSafeIntegerArray,"var arr = [ -3.0, new Number(0.0), 2.0 ];\nvar bool = isSafeIntegerArray( arr )\narr = [ -3.0, '3.0' ];\nbool = isSafeIntegerArray( arr )\n"
+isSameValue,"var bool = isSameValue( true, true )\nbool = isSameValue( {}, {} )\nbool = isSameValue( -0.0, -0.0 )\nbool = isSameValue( -0.0, 0.0 )\nbool = isSameValue( NaN, NaN )\n"
+isSameValueZero,"var bool = isSameValueZero( true, true )\nbool = isSameValueZero( {}, {} )\nbool = isSameValueZero( -0.0, -0.0 )\nbool = isSameValueZero( -0.0, 0.0 )\nbool = isSameValueZero( NaN, NaN )\n"
+isSharedArrayBuffer,"\n// Assuming an environment supports SharedArrayBuffer...\nvar bool = isSharedArrayBuffer( new SharedArrayBuffer( 10 ) )\nbool = isSharedArrayBuffer( [] )\n"
+isSkewCentrosymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 2, 1, -1, -2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewCentrosymmetricMatrix( M )\nbool = isSkewCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewCentrosymmetricMatrix( 3.14 )\nbool = isSkewCentrosymmetricMatrix( {} )\n"
+isSkewPersymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 0, 0, -1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewPersymmetricMatrix( M )\nbool = isSkewPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewPersymmetricMatrix( 3.14 )\nbool = isSkewPersymmetricMatrix( {} )\n"
+isSkewSymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, -1, 1, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewSymmetricMatrix( M )\nbool = isSkewSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewSymmetricMatrix( 3.14 )\nbool = isSkewSymmetricMatrix( {} )\n"
+isSquareMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSquareMatrix( M )\nbool = isSquareMatrix( [ 1, 2, 3, 4 ] )\nbool = isSquareMatrix( 3.14 )\nbool = isSquareMatrix( {} )\n"
+isStrictEqual,"var bool = isStrictEqual( true, true )\nbool = isStrictEqual( {}, {} )\nbool = isStrictEqual( -0.0, -0.0 )\nbool = isStrictEqual( -0.0, 0.0 )\nbool = isStrictEqual( NaN, NaN )\n"
+isString,"var bool = isString( 'beep' )\nbool = isString( new String( 'beep' ) )\nbool = isString( 5 )\n"
+isStringArray,"var bool = isStringArray( [ 'abc', 'def' ] )\nbool = isStringArray( [ 'abc', 123 ] )\n"
+isSymbol,"var bool = isSymbol( Symbol( 'beep' ) )\nbool = isSymbol( Object( Symbol( 'beep' ) ) )\nbool = isSymbol( {} )\nbool = isSymbol( null )\nbool = isSymbol( true )\n"
+isSymbolArray,"var bool = isSymbolArray( [ Symbol( 'beep' ), Symbol( 'boop' ) ] )\nbool = isSymbolArray( Symbol( 'beep' ) )\nbool = isSymbolArray( [] )\nbool = isSymbolArray( {} )\nbool = isSymbolArray( null )\nbool = isSymbolArray( true )\n"
+isSymmetricMatrix,"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSymmetricMatrix( M )\nbool = isSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSymmetricMatrix( 3.14 )\nbool = isSymmetricMatrix( {} )\n"
+isSyntaxError,"var bool = isSyntaxError( new SyntaxError( 'beep' ) )\nbool = isSyntaxError( {} )\n"
+isTruthy,"bool = isTruthy( {} )\nbool = isTruthy( [] )\nbool = isTruthy( false )\nbool = isTruthy( '' )\nbool = isTruthy( 0 )\nbool = isTruthy( null )\nbool = isTruthy( void 0 )\nbool = isTruthy( NaN )\n"
+isTruthyArray,"var bool = isTruthyArray( [ {}, [] ] )\nbool = isTruthyArray( [ null, '' ] )\nbool = isTruthyArray( [] )\n"
+isTypedArray,"var bool = isTypedArray( new Int8Array( 10 ) )\n"
+isTypedArrayLength,"var bool = isTypedArrayLength( 5 )\nbool = isTypedArrayLength( 2.0e200 )\nbool = isTypedArrayLength( -3.14 )\nbool = isTypedArrayLength( null )\n"
+isTypedArrayLike,"var bool = isTypedArrayLike( new Int16Array() )\nbool = isTypedArrayLike({\n 'length': 10,\n 'byteOffset': 0,\n 'byteLength': 10,\n 'BYTES_PER_ELEMENT': 4\n})\n"
+isTypeError,"var bool = isTypeError( new TypeError( 'beep' ) )\nbool = isTypeError( {} )\n"
+isUint8Array,"var bool = isUint8Array( new Uint8Array( 10 ) )\nbool = isUint8Array( [] )\n"
+isUint8ClampedArray,"var bool = isUint8ClampedArray( new Uint8ClampedArray( 10 ) )\nbool = isUint8ClampedArray( [] )\n"
+isUint16Array,"var bool = isUint16Array( new Uint16Array( 10 ) )\nbool = isUint16Array( [] )\n"
+isUint32Array,"var bool = isUint32Array( new Uint32Array( 10 ) )\nbool = isUint32Array( [] )\n"
+isUNCPath,"var bool = isUNCPath( '\\\\server\\share\\foo\\bar\\baz' )\nbool = isUNCPath( '/foo/bar/baz' )\n"
+isUndefined,"var bool = isUndefined( void 0 )\nbool = isUndefined( null )\n"
+isUndefinedOrNull,"var bool = isUndefinedOrNull( void 0 )\nbool = isUndefinedOrNull( null )\nbool = isUndefinedOrNull( false )\n"
+isUnityProbabilityArray,"var bool = isUnityProbabilityArray( [ 0.25, 0.5, 0.25 ] )\nbool = isUnityProbabilityArray( new Uint8Array( [ 0, 1 ] ) )\nbool = isUnityProbabilityArray( [ 0.4, 0.4, 0.4 ] )\nbool = isUnityProbabilityArray( [ 3.14, 0.0 ] )\n"
+isUppercase,"var bool = isUppercase( 'HELLO' )\nbool = isUppercase( 'World' )\n"
+isURI,"var bool = isURI( 'http://google.com' )\nbool = isURI( 'http://localhost/' )\nbool = isURI( 'http://example.w3.org/path%20with%20spaces.html' )\nbool = isURI( 'ftp://ftp.is.co.za/rfc/rfc1808.txt' )\n\n// No scheme:\nbool = isURI( '' )\nbool = isURI( 'foo@bar' )\nbool = isURI( '://foo/' )\n\n// Illegal characters:\nbool = isURI( 'http://' )\n\n// Invalid path:\nbool = isURI( 'http:////foo.html' )\n\n// Incomplete hex escapes:\nbool = isURI( 'http://example.w3.org/%a' )\n"
+isURIError,"var bool = isURIError( new URIError( 'beep' ) )\nbool = isURIError( {} )\n"
+isVectorLike,"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 1;\nM.shape = [ 4 ];\nM.strides = [ 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isVectorLike( M )\nbool = isVectorLike( [ 1, 2, 3, 4 ] )\nbool = isVectorLike( 3.14 )\nbool = isVectorLike( {} )\n"
+isWhitespace,"var bool = isWhitespace( ' ' )\nbool = isWhitespace( 'abcdef' )\nbool = isWhitespace( '' )\n"
+isWritableProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isWritableProperty( obj, 'boop' )\nbool = isWritableProperty( obj, 'beep' )\n"
+isWritablePropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isWritablePropertyIn( obj, 'boop' )\nbool = isWritablePropertyIn( obj, 'beep' )\n"
+isWriteOnlyProperty,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isWriteOnlyProperty( obj, 'boop' )\nbool = isWriteOnlyProperty( obj, 'beep' )\n"
+isWriteOnlyPropertyIn,"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isWriteOnlyPropertyIn( obj, 'boop' )\nbool = isWriteOnlyPropertyIn( obj, 'beep' )\n"
+iterAdd,"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterAdd( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterAdvance,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar it = iterAdvance( arr, 4 );\nvar v = it.next().value\nvar bool = it.next().done\n"
+iterAny,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar bool = iterAny( arr )\n"
+iterAnyBy,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v === 1 ); };\nvar bool = iterAnyBy( arr, fcn )\n"
+iterator2array,"var opts = { 'iter': 10 };\nvar arr = iterator2array( random.iterators.randu( opts ) )\n"
+iterator2arrayview,"var it = random.iterators.randu({ 'iter': 10 });\nvar out = new Float64Array( 20 );\nvar arr = iterator2arrayview( it, out, 5, 15 )\n"
+iterator2arrayviewRight,"var it = random.iterators.randu({ 'iter': 10 });\nvar out = new Float64Array( 20 );\nvar arr = iterator2arrayviewRight( it, out, 5, 15 )\n"
+iteratorStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar it = random.iterators.randu( opts );\nvar s = iteratorStream( it );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+IteratorSymbol,"var s = IteratorSymbol\n"
+iterawgn,"var src = iterSineWave();\nvar it = iterawgn( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n"
+iterawln,"var src = iterSineWave();\nvar it = iterawln( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n"
+iterawun,"var src = iterSineWave();\nvar it = iterawun( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n"
+iterBartlettHannPulse,"var it = iterBartlettHannPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterBartlettPulse,"var it = iterBartlettPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterConcat,"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = array2iterator( [ 3, 4 ] );\nvar it = iterConcat( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterConstant,"var it = iterConstant( 3.14 );\nvar v = it.next().value\nv = it.next().value\n"
+iterCosineWave,"var it = iterCosineWave();\nvar v = it.next().value\nv = it.next().value\n"
+iterCounter,"var it = iterCounter( random.iterators.randu() );\nvar v = it.next().value\nv = it.next().value\n"
+itercugmean,"var arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nvar it = itercugmean( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n"
+itercuhmean,"var arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nvar it = itercuhmean( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n"
+itercumax,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumax( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercumaxabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumaxabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercumean,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumean( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercumeanabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumeanabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercumeanabs2,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumeanabs2( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercumidrange,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumidrange( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n"
+itercumin,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumin( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercuminabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercuminabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itercuprod,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercuprod( arr );\nvar p = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n"
+itercurange,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercurange( arr );\nvar r = it.next().value\nr = it.next().value\nr = it.next().value\nr = it.next().value\n"
+itercusum,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusum( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+itercusumabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusumabs( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+itercusumabs2,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusumabs2( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+iterDedupe,"var arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nvar it = iterDedupe( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\n"
+iterDedupeBy,"var arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nfunction fcn( v ) { return v; };\nvar it = iterDedupeBy( arr, fcn );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\n"
+iterDiracComb,"var it = iterDiracComb();\nvar v = it.next().value\nv = it.next().value\n"
+iterDivide,"var it1 = array2iterator( [ 3.0, 2.0 ] );\nvar it2 = array2iterator( [ 1.0, 4.0 ] );\nvar it = iterDivide( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterEmpty,"var it = iterEmpty();\nvar bool = it.next().done\n"
+iterEvery,"var arr = array2iterator( [ 1, 1, 1, 1, 0 ] );\nvar bool = iterEvery( arr )\n"
+iterEveryBy,"var arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nvar bool = iterEveryBy( arr, fcn )\n"
+iterFibonacci,"var it = iterFibonacci();\nvar v = it.next().value\nv = it.next().value\n"
+iterFill,"var it = iterFill( random.iterators.randu(), 3.14, 0, 2 );\nvar r = it.next().value\nr = it.next().value\nr = it.next().value\n"
+iterFilter,"function f( v ) { return ( v > 2 ); };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterFilter( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n"
+iterFilterMap,"function f( v ) { if ( v > 2 ) { return v * 10 }; };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterFilterMap( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n"
+iterFirst,"var arr = array2iterator( [ 1, 0, 0, 0, 0 ] );\nvar v = iterFirst( arr )\n"
+iterFlatTopPulse,"var it = iterFlatTopPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterFlow,"var o = {};\no.head = iterHead;\no.some = iterSome;\nvar fiter = iterFlow( o )\n"
+iterForEach,"function f( v ) { if ( v !== v ) { throw new Error( 'beep' ); } };\nvar it = iterForEach( random.iterators.randu(), f );\nvar r = it.next().value\nr = it.next().value\n"
+iterHannPulse,"var it = iterHannPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterHead,"var it = iterHead( random.iterators.randu(), 5 );\nvar r = it.next().value\nr = it.next().value\n"
+iterIntersection,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nvar it = iterIntersection( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterIntersectionByHash,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nfunction f( v ) { return v.toString(); };\nvar it = iterIntersectionByHash( it1, it2, f );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterLanczosPulse,"var it = iterLanczosPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterLast,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar v = iterLast( arr )\n"
+iterLength,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar len = iterLength( arr )\n"
+iterMap,"function f( v ) { return v * 10.0; };\nvar it = iterMap( random.iterators.randu(), f );\nvar r = it.next().value\nr = it.next().value\n"
+iterMapN,"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nfunction fcn( x, y ) { return x + y; };\nvar it = iterMapN( it1, it2, fcn );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+itermax,"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = itermax( arr )\n"
+itermaxabs,"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = itermaxabs( arr )\n"
+itermean,"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar m = itermean( arr )\n"
+itermeanabs,"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermeanabs( arr )\n"
+itermeanabs2,"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermeanabs2( arr )\n"
+itermidrange,"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar v = itermidrange( arr )\n"
+itermin,"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermin( arr )\n"
+iterminabs,"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = iterminabs( arr )\n"
+itermmax,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmax( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermmaxabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmaxabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermmean,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmean( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermmeanabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmeanabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermmeanabs2,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmeanabs2( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermmidrange,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmidrange( arr, 3 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n"
+itermmin,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmin( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermminabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermminabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+iterMod,"var it1 = array2iterator( [ 3.0, 2.0 ] );\nvar it2 = array2iterator( [ 1.0, 4.0 ] );\nvar it = iterMod( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+itermprod,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermprod( arr, 3 );\nvar p = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n"
+itermrange,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermrange( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n"
+itermsum,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsum( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+itermsumabs,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsumabs( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+itermsumabs2,"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsumabs2( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n"
+iterMultiply,"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterMultiply( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterNone,"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar bool = iterNone( arr )\n"
+iterNoneBy,"var arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v <= 0 ); };\nvar bool = iterNoneBy( arr, fcn )\n"
+iterNonFibonacci,"var it = iterNonFibonacci();\nvar v = it.next().value\nv = it.next().value\n"
+iterNth,"var arr = array2iterator( [ 0, 0, 1, 0, 0 ] );\nvar v = iterNth( arr, 3 )\n"
+iterPeriodicSinc,"var it = iterPeriodicSinc( 7 );\nvar v = it.next().value\nv = it.next().value\n"
+iterPipeline,"var it1 = iterThunk( iterHead, 100 );\nfunction f( r ) { return ( r > 0.95 ); };\nvar it2 = iterThunk( iterSomeBy, 5, f );\nvar p = iterPipeline( it1, it2 );\nvar bool = p( random.iterators.randu() )\n"
+iterPop,"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterPop( it1 );\nvar v = it2.next().value\nvar bool = it2.next().done\n"
+iterprod,"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar s = iterprod( arr )\n"
+iterPulse,"var it = iterPulse();\nvar v = it.next().value\nv = it.next().value\n"
+iterPush,"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterPush( it1, 3, 4 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n"
+iterrange,"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar v = iterrange( arr )\n"
+iterReject,"function f( v ) { return ( v > 2 ); };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterReject( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n"
+iterReplicate,"var it1 = array2iterator( [ 1, 2, 3, 4 ] );\nvar it2 = iterReplicate( it1, 2 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n"
+iterReplicateBy,"var it1 = array2iterator( [ 1, 2, 3, 4 ] );\nfunction f( v, i ) { return i + 1; };\nvar it2 = iterReplicateBy( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n"
+iterSawtoothWave,"var it = iterSawtoothWave();\nvar v = it.next().value\nv = it.next().value\n"
+iterShift,"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterShift( it1 );\nvar v = it2.next().value\nvar bool = it2.next().done\n"
+iterSineWave,"var it = iterSineWave();\nvar v = it.next().value\nv = it.next().value\n"
+iterSlice,"var it = iterSlice( random.iterators.randu(), 5, 10 );\nvar r = it.next().value\nr = it.next().value\n"
+iterSome,"var arr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nvar bool = iterSome( arr, 3 )\n"
+iterSomeBy,"var arr = array2iterator( [ 1, 1, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nvar bool = iterSomeBy( arr, 3, fcn )\n"
+iterSquareWave,"var it = iterSquareWave();\nvar v = it.next().value\nv = it.next().value\n"
+iterstdev,"var arr = array2iterator( [ 2.0, -5.0 ] );\nvar m = iterstdev( arr )\n"
+iterSubtract,"var it1 = array2iterator( [ 1.0, 5.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterSubtract( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+itersum,"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar s = itersum( arr )\n"
+itersumabs,"var arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\nvar s = itersumabs( arr )\n"
+itersumabs2,"var arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\nvar s = itersumabs2( arr )\n"
+iterThunk,"var fcn = iterThunk( iterSome, 3 );\nvar arr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nvar bool = fcn( arr )\n"
+iterTriangleWave,"var it = iterTriangleWave();\nvar v = it.next().value\nv = it.next().value\n"
+iterUnion,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nvar it = iterUnion( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nvar bool = it.next().done\n"
+iterUnique,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = iterUnique( it1 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n"
+iterUniqueBy,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( a, b ) { return ( a !== b ); };\nvar it2 = iterUniqueBy( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n"
+iterUniqueByHash,"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( v ) { return v.toString(); };\nvar it2 = iterUniqueByHash( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n"
+iterUnshift,"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterUnshift( it1, 3, 4 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n"
+itervariance,"var arr = array2iterator( [ 2.0, -5.0 ] );\nvar s2 = itervariance( arr )\n"
+joinStream,"var s = joinStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+keyBy,"function toKey( v ) { return v.a; };\nvar arr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyBy( arr, toKey )\n"
+keyByRight,"function toKey( v ) { return v.a; };\nvar arr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyByRight( arr, toKey )\n"
+keysIn,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = keysIn( obj )\n"
+kruskalTest,"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = kruskalTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = kruskalTest( arr, { 'groups': groups })\n"
+kstest,"\n// Verify that data is drawn from a normal distribution:\nvar rnorm = base.random.normal.factory({ 'seed': 4839 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < 100; i++ ) { x[ i ] = rnorm( 3.0, 1.0 ); }\n\n// Test against N(0,1)\nvar out = kstest( x, 'normal', 0.0, 1.0 )\n\n// Test against N(3,1)\nout = kstest( x, 'normal', 3.0, 1.0 )\n\n// Verify that data is drawn from a uniform distribution:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 })\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0 )\n\n// Print output:\nout.print()\n\n// Set custom significance level:\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alpha': 0.1 })\n\n// Carry out one-sided hypothesis tests:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'less' })\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'greater' })\n\n// Set `sorted` option to true when data is in increasing order:\nx = [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 ];\nout = kstest( x, 'uniform', 0.0, 1.0, { 'sorted': true })\n"
+LinkedList,"var list = LinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n"
+linspace,"var arr = linspace( 0, 100, 6 )\n"
+LIU_NEGATIVE_OPINION_WORDS_EN,"var list = LIU_NEGATIVE_OPINION_WORDS_EN()\n"
+LIU_POSITIVE_OPINION_WORDS_EN,"var list = LIU_POSITIVE_OPINION_WORDS_EN()\n"
+LN_HALF,"LN_HALF\n"
+LN_PI,"LN_PI\n"
+LN_SQRT_TWO_PI,"LN_SQRT_TWO_PI\n"
+LN_TWO_PI,"LN_TWO_PI\n"
+LN2,"LN2\n"
+LN10,"LN10\n"
+LOG2E,"LOG2E\n"
+LOG10E,"LOG10E\n"
+logspace,"var arr = logspace( 0, 2, 6 )\n"
+lowercase,"var out = lowercase( 'bEEp' )\n"
+lowercaseKeys,"var obj = { 'A': 1, 'B': 2 };\nvar out = lowercaseKeys( obj )\n"
+lowess,"var x = new Float64Array( 100 );\nvar y = new Float64Array( x.length );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = i;\n y[ i ] = ( 0.5*i ) + ( 10.0*base.random.randn() );\n}\nvar out = lowess( x, y );\nvar yhat = out.y;\nvar h = Plot( [ x, x ], [ y, yhat ] );\nh.lineStyle = [ 'none', '-' ];\nh.symbols = [ 'closed-circle', 'none' ];\nh.view( 'window' );\n"
+lpad,"var out = lpad( 'a', 5 )\nout = lpad( 'beep', 10, 'b' )\nout = lpad( 'boop', 12, 'beep' )\n"
+ltrim,"var out = ltrim( ' \r\n\t Beep \t\t\n ' )\n"
+MALE_FIRST_NAMES_EN,"var list = MALE_FIRST_NAMES_EN()\n"
+mapFun,"function fcn( i ) { return i; };\nvar arr = mapFun( fcn, 5 )\n"
+mapFunAsync,"\n// Basic usage:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nmapFunAsync( fcn, 10, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nvar opts = { 'limit': 2 };\nmapFunAsync( fcn, 10, opts, done )\n\n// Sequential invocation:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nvar opts = { 'series': true };\nmapFunAsync( fcn, 10, opts, done )\n"
+mapKeys,"function transform( key, value ) { return key + value; };\nvar obj = { 'a': 1, 'b': 2 };\nvar out = mapKeys( obj, transform )\n"
+mapKeysAsync,"\n// Basic usage:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar obj = { 'a': 1, 'b': 2 };\nmapKeysAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'limit': 2 };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'series': true };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n"
+mapValues,"function transform( value, key ) { return key + value; };\nvar obj = { 'a': 1, 'b': 2 };\nvar out = mapValues( obj, transform )\n"
+mapValuesAsync,"\n// Basic usage:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar obj = { 'a': 1, 'b': 2 };\nmapValuesAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'limit': 2 };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'series': true };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n"
+MAX_ARRAY_LENGTH,"MAX_ARRAY_LENGTH\n"
+MAX_TYPED_ARRAY_LENGTH,"MAX_TYPED_ARRAY_LENGTH\n"
+memoize,"function factorial( n ) {\n var prod;\n var i;\n prod = 1;\n for ( i = n; i > 1; i-- ) {\n prod *= i;\n }\n return prod;\n};\nvar memoized = memoize( factorial );\nvar v = memoized( 5 )\nv = memoized( 5 )\n"
+merge,"var target = { 'a': 'beep' };\nvar source = { 'a': 'boop', 'b': 'bap' };\nvar out = merge( target, source )\nvar bool = ( out === target )\n"
+MILLISECONDS_IN_DAY,"var days = 3.14;\nvar ms = days * MILLISECONDS_IN_DAY\n"
+MILLISECONDS_IN_HOUR,"var hrs = 3.14;\nvar ms = hrs * MILLISECONDS_IN_HOUR\n"
+MILLISECONDS_IN_MINUTE,"var mins = 3.14;\nvar ms = mins * MILLISECONDS_IN_MINUTE\n"
+MILLISECONDS_IN_SECOND,"var secs = 3.14;\nvar ms = secs * MILLISECONDS_IN_SECOND\n"
+MILLISECONDS_IN_WEEK,"var weeks = 3.14;\nvar ms = weeks * MILLISECONDS_IN_WEEK\n"
+MINARD_NAPOLEONS_MARCH,"var data = MINARD_NAPOLEONS_MARCH();\nvar army = data.army\nvar cities = data.cities\nvar labels = data.labels\nvar river = data.river\nvar t = data.temperature\n"
+MINUTES_IN_DAY,"var days = 3.14;\nvar mins = days * MINUTES_IN_DAY\n"
+MINUTES_IN_HOUR,"var hrs = 3.14;\nvar mins = hrs * MINUTES_IN_HOUR\n"
+MINUTES_IN_WEEK,"var wks = 3.14;\nvar mins = wks * MINUTES_IN_WEEK\n"
+minutesInMonth,"var num = minutesInMonth()\nnum = minutesInMonth( 2 )\nnum = minutesInMonth( 2, 2016 )\nnum = minutesInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = minutesInMonth( 'feb', 2016 )\nnum = minutesInMonth( 'february', 2016 )\n"
+minutesInYear,"var num = minutesInYear()\nnum = minutesInYear( 2016 )\nnum = minutesInYear( 2017 )\n"
+MOBY_DICK,"var data = MOBY_DICK()\n"
+MONTH_NAMES_EN,"var list = MONTH_NAMES_EN()\n"
+MONTHS_IN_YEAR,"var yrs = 3.14;\nvar mons = yrs * MONTHS_IN_YEAR\n"
+moveProperty,"var obj1 = { 'a': 'b' };\nvar obj2 = {};\nvar bool = moveProperty( obj1, 'a', obj2 )\nbool = moveProperty( obj1, 'c', obj2 )\n"
+namedtypedtuple,"var opts = {};\nopts.name = 'Point';\nvar factory = namedtypedtuple( [ 'x', 'y' ], opts );\nvar tuple = factory();\n"
+nativeClass,"var str = nativeClass( 'a' )\nstr = nativeClass( 5 )\nfunction Beep(){};\nstr = nativeClass( new Beep() )\n"
+ndarray,"var ctor = ndarray( 'generic', 2 )\n\n// To create a new instance...\nvar b = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n"
+ndarrayCastingModes,"var out = ndarrayCastingModes()\n"
+ndarrayDataTypes,"var out = ndarrayDataTypes()\n"
+ndarrayIndexModes,"var out = ndarrayIndexModes()\n"
+ndarrayMemoized,"var ctor = ndarrayMemoized( 'generic', 2 )\nvar f = ndarrayMemoized( 'generic', 2 )\nvar bool = ( f === ctor )\n\n// To create a new instance...\nvar b = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n"
+ndarrayMinDataType,"var dt = ndarrayMinDataType( 3.141592653589793 )\ndt = ndarrayMinDataType( 3 )\ndt = ndarrayMinDataType( -3 )\ndt = ndarrayMinDataType( '-3' )\n"
+ndarrayNextDataType,"var out = ndarrayNextDataType( 'float32' )\n"
+ndarrayOrders,"var out = ndarrayOrders()\n"
+ndarrayPromotionRules,"var out = ndarrayPromotionRules( 'float32', 'int32' )\n"
+ndarraySafeCasts,"var out = ndarraySafeCasts( 'float32' )\n"
+ndarraySameKindCasts,"var out = ndarraySameKindCasts( 'float32' )\n"
+NIGHTINGALES_ROSE,"var data = NIGHTINGALES_ROSE()\n"
+NINF,"NINF\n"
+NODE_VERSION,"NODE_VERSION\n"
+none,"var arr = [ 0, 0, 0, 0, 0 ];\nvar bool = none( arr )\n"
+noneBy,"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = noneBy( arr, negative )\n"
+noneByAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n"
+noneByRight,"function positive( v ) { return ( v > 0 ); };\nvar arr = [ -1, -2, -3, -4 ];\nvar bool = noneByRight( arr, positive )\n"
+noneByRightAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n"
+nonEnumerableProperties,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar props = nonEnumerableProperties( obj )\n"
+nonEnumerablePropertiesIn,"var props = nonEnumerablePropertiesIn( [] )\n"
+nonEnumerablePropertyNames,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = nonEnumerablePropertyNames( obj )\n"
+nonEnumerablePropertyNamesIn,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = nonEnumerablePropertyNamesIn( obj )\n"
+nonEnumerablePropertySymbols,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = nonEnumerablePropertySymbols( obj )\n"
+nonEnumerablePropertySymbolsIn,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = nonEnumerablePropertySymbolsIn( obj )\n"
+noop,"noop();\n"
+now,"var ts = now()\n"
+NUM_CPUS,"NUM_CPUS\n"
+Number,"var v = new Number( 5 )\n"
+objectEntries,"var obj = { 'beep': 'boop', 'foo': 'bar' };\nvar entries = objectEntries( obj )\n"
+objectEntriesIn,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar entries = objectEntriesIn( obj )\n"
+objectFromEntries,"var entries = [ [ 'beep', 'boop' ], [ 'foo', 'bar' ] ];\nvar obj = objectFromEntries( entries )\n"
+objectInverse,"\n// Basic usage:\nvar obj = { 'a': 'beep', 'b': 'boop' };\nvar out = objectInverse( obj )\n\n// Duplicate values:\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverse( obj )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverse( obj, { 'duplicates': false } )\n"
+objectInverseBy,"\n// Basic usage:\nfunction transform( key, value ) { return key + value; };\nvar obj = { 'a': 'beep', 'b': 'boop' };\nvar out = objectInverseBy( obj, transform )\n\n// Duplicate values:\nfunction transform( key, value ) { return value; };\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverseBy( obj, transform )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverseBy( obj, { 'duplicates': false }, transform )\n"
+objectKeys,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = objectKeys( obj )\n"
+objectValues,"var obj = { 'beep': 'boop', 'foo': 'bar' };\nvar vals = objectValues( obj )\n"
+objectValuesIn,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar values = objectValuesIn( obj )\n"
+omit,"var obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = omit( obj1, 'b' )\n"
+omitBy,"function predicate( key, value ) { return ( value > 1 ); };\nvar obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = omitBy( obj1, predicate )\n"
+openURL,"var out = openURL( 'https://google.com' );\n"
+PACE_BOSTON_HOUSE_PRICES,"var data = PACE_BOSTON_HOUSE_PRICES()\n"
+pad,"\n// Standard usage:\nvar out = pad( 'a', 5 )\n\n// Left pad:\nout = pad( 'a', 10, { 'lpad': 'b' })\n\n// Right pad:\nout = pad( 'a', 12, { 'rpad': 'b' })\n\n// Center an input string:\nvar opts = { 'lpad': 'a', 'rpad': 'c' };\nout = pad( 'b', 11, opts )\n\n// Left center:\nopts.centerRight = false;\nout = pad( 'b', 10, opts )\n\n// Right center:\nopts.centerRight = true;\nout = pad( 'b', 10, opts )\n\n// Output string always length `len`:\nopts = { 'lpad': 'boop', 'rpad': 'woot' };\nout = pad( 'beep', 10, opts )\n\n// Pad right, trim right:\nout = pad( 'beep', 2 )\n\n// Pad left, trim left:\nopts = { 'lpad': 'b' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both:\nopts = { 'lpad': '@', 'rpad': '!' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both starting from left:\nout = pad( 'abcdef', 3, opts )\n\n// Pad both, trim both starting from right:\nopts.centerRight = true;\nout = pad( 'abcdef', 3, opts )\n"
+papply,"function add( x, y ) { return x + y; };\nvar add2 = papply( add, 2 );\nvar sum = add2( 3 )\n"
+papplyRight,"function say( text, name ) { return text + ', ' + name + '.'; };\nvar toGrace = papplyRight( say, 'Grace Hopper' );\nvar str = toGrace( 'Hello' )\nstr = toGrace( 'Thank you' )\n"
+parallel,"function done( error ) { if ( error ) { throw error; } };\nvar files = [ './a.js', './b.js' ];\nparallel( files, done );\n\n// Specify the number of workers:\nvar opts = { 'workers': 8 };\nparallel( files, opts, done );\n"
+parseJSON,"var obj = parseJSON( '{\"beep\":\"boop\"}' )\n\n// Provide a reviver:\nfunction reviver( key, value ) {\n if ( key === '' ) { return value; }\n if ( key === 'beep' ) { return value; }\n};\nvar str = '{\"beep\":\"boop\",\"a\":\"b\"}';\nvar out = parseJSON( str, reviver )\n"
+PATH_DELIMITER,"PATH_DELIMITER\n\n// POSIX environment:\nvar path = '/usr/bin:/bin:/usr/sbin';\nvar parts = path.split( PATH_DELIMITER )\n\n// Windows environment:\npath = 'C:\\Windows\\system32;C:\\Windows';\nparts = path.split( PATH_DELIMITER )\n"
+PATH_DELIMITER_POSIX,"PATH_DELIMITER_POSIX\nvar PATH = '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin';\nvar paths = PATH.split( PATH_DELIMITER_POSIX )\n"
+PATH_DELIMITER_WIN32,"PATH_DELIMITER_WIN32\nvar PATH = 'C:\\Windows\\system32;C:\\Windows;C:\\Program Files\\node\\';\nvar paths = PATH.split( PATH_DELIMITER_WIN32 )\n"
+PATH_SEP,"PATH_SEP\n\n// Windows environment:\nvar parts = 'foo\\bar\\baz'.split( PATH_SEP )\n\n// POSIX environment:\nparts = 'foo/bar/baz'.split( PATH_SEP )\n"
+PATH_SEP_POSIX,"PATH_SEP_POSIX\nvar parts = 'foo/bar/baz'.split( PATH_SEP_POSIX )\n"
+PATH_SEP_WIN32,"PATH_SEP_WIN32\nvar parts = 'foo\\bar\\baz'.split( PATH_SEP_WIN32 )\n"
+pcorrtest,"var rho = 0.5;\nvar x = new Array( 300 );\nvar y = new Array( 300 );\nfor ( var i = 0; i < 300; i++ ) {\n x[ i ] = base.random.normal( 0.0, 1.0 );\n y[ i ] = ( rho * x[ i ] ) + base.random.normal( 0.0,\n base.sqrt( 1.0 - (rho*rho) ) );\n}\nvar out = pcorrtest( x, y )\n\n// Print output:\nvar table = out.print()\n"
+percentEncode,"var out = percentEncode( '☃' )\n"
+PHI,"PHI\n"
+PI,"PI\n"
+PI_SQUARED,"PI_SQUARED\n"
+pick,"var obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = pick( obj1, 'b' )\n"
+pickBy,"function predicate( key, value ) {\n return ( value > 1 );\n};\nvar obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = pickBy( obj1, predicate )\n"
+PINF,"PINF\n"
+pkg2alias,"var v = pkg2alias( '@stdlib/math/base/special/sin' )\n"
+pkg2related,"var v = pkg2related( '@stdlib/math/base/special/sin' )\n"
+PLATFORM,"PLATFORM\n"
+plot,"var plot = plot()\n\n// Provide plot data at instantiation:\nvar x = [[0.10, 0.20, 0.30]];\nvar y = [[0.52, 0.79, 0.64]];\nplot = plot( x, y )\n"
+Plot,"var plot = Plot()\n\n// Provide plot data at instantiation:\nvar x = [[0.10, 0.20, 0.30]];\nvar y = [[0.52, 0.79, 0.64]];\nplot = Plot( x, y )\n"
+pluck,"var arr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nvar out = pluck( arr, 'a' )\narr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nout = pluck( arr, 'a', { 'copy': false } )\nvar bool = ( arr[ 0 ] === out[ 0 ] )\n"
+pop,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar out = pop( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = pop( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = pop( arr )\n"
+prepend,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = prepend( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = prepend( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = prepend( arr, [ 2.0, 3.0 ] )\n"
+properties,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = properties( obj )\n"
+propertiesIn,"var props = propertiesIn( [] )\n"
+propertyDescriptor,"var obj = { 'a': 'b' };\nvar desc = propertyDescriptor( obj, 'a' )\n"
+propertyDescriptorIn,"var obj = { 'a': 'b' };\nvar desc = propertyDescriptorIn( obj, 'a' )\n"
+propertyDescriptors,"var obj = { 'a': 'b' };\nvar desc = propertyDescriptors( obj )\n"
+propertyDescriptorsIn,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar desc = propertyDescriptorsIn( obj )\n"
+propertyNames,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = propertyNames( obj )\n"
+propertyNamesIn,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = propertyNamesIn( obj )\n"
+propertySymbols,"var s = propertySymbols( {} )\n"
+propertySymbolsIn,"var s = propertySymbolsIn( [] )\n"
+Proxy,"function get( obj, prop ) { return obj[ prop ] * 2.0 };\nvar h = { 'get': get };\nvar p = new Proxy( {}, h );\np.a = 3.14;\np.a\n"
+push,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = push( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = push( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 0 };\narr = push( arr, 1.0, 2.0 )\n"
+quarterOfYear,"var q = quarterOfYear( new Date() )\nq = quarterOfYear( 4 )\nq = quarterOfYear( 'June' )\n\n// Other ways to supply month:\nq = quarterOfYear( 'April' )\nq = quarterOfYear( 'apr' )\n"
+random.iterators.arcsine,"var it = random.iterators.arcsine( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.bernoulli,"var it = random.iterators.bernoulli( 0.3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.beta,"var it = random.iterators.beta( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.betaprime,"var it = random.iterators.betaprime( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.binomial,"var it = random.iterators.binomial( 10, 0.3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.boxMuller,"var it = random.iterators.boxMuller();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.cauchy,"var it = random.iterators.cauchy( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.chi,"var it = random.iterators.chi( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.chisquare,"var it = random.iterators.chisquare( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.cosine,"var it = random.iterators.cosine( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.discreteUniform,"var it = random.iterators.discreteUniform( 0, 3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.erlang,"var it = random.iterators.erlang( 1, 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.exponential,"var it = random.iterators.exponential( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.f,"var it = random.iterators.f( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.frechet,"var it = random.iterators.frechet( 1.0, 1.0, 0.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.gamma,"var it = random.iterators.gamma( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.geometric,"var it = random.iterators.geometric( 0.3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.gumbel,"var it = random.iterators.gumbel( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.hypergeometric,"var it = random.iterators.hypergeometric( 20, 10, 7 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.improvedZiggurat,"var it = random.iterators.improvedZiggurat();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.invgamma,"var it = random.iterators.invgamma( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.kumaraswamy,"var it = random.iterators.kumaraswamy( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.laplace,"var it = random.iterators.laplace( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.levy,"var it = random.iterators.levy( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.logistic,"var it = random.iterators.logistic( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.lognormal,"var it = random.iterators.lognormal( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.minstd,"var it = random.iterators.minstd();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.minstdShuffle,"var it = random.iterators.minstdShuffle();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.mt19937,"var it = random.iterators.mt19937();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.negativeBinomial,"var it = random.iterators.negativeBinomial( 10, 0.3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.normal,"var it = random.iterators.normal( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.pareto1,"var it = random.iterators.pareto1( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.poisson,"var it = random.iterators.poisson( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.randi,"var it = random.iterators.randi();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.randn,"var it = random.iterators.randn();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.randu,"var it = random.iterators.randu();\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.rayleigh,"var it = random.iterators.rayleigh( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.t,"var it = random.iterators.t( 1.5 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.triangular,"var it = random.iterators.triangular( 0.0, 1.0, 0.3 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.uniform,"var it = random.iterators.uniform( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.iterators.weibull,"var it = random.iterators.weibull( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n"
+random.streams.arcsine,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.arcsine( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.bernoulli,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.bernoulli( 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.beta,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.beta( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.betaprime,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.betaprime( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.binomial,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.binomial( 20, 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.boxMuller,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.boxMuller( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.cauchy,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.cauchy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.chi,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.chi( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.chisquare,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.chisquare( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.cosine,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.cosine( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.discreteUniform,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.discreteUniform( 2, 5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.erlang,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.erlang( 2, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.exponential,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.exponential( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.f,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.f( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.gamma,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.gamma( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.geometric,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.geometric( 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.gumbel,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.gumbel( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.improvedZiggurat,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.improvedZiggurat( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.invgamma,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.invgamma( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.kumaraswamy,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.kumaraswamy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.laplace,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.laplace( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.levy,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.levy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.logistic,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.logistic( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.lognormal,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.lognormal( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.minstd,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.minstd( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.minstdShuffle,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.minstdShuffle( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.mt19937,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.mt19937( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.negativeBinomial,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.negativeBinomial( 20.0, 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.normal,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.normal( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.pareto1,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.pareto1( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.poisson,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.poisson( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.randi,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randi( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.randn,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randn( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.randu,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randu( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.rayleigh,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.rayleigh( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.t,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.t( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.uniform,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.uniform( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+random.streams.weibull,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.weibull( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+ranks,"var arr = [ 1.1, 2.0, 3.5, 0.0, 2.4 ] ;\nvar out = ranks( arr )\n\n// Ties are averaged:\narr = [ 2, 2, 1, 4, 3 ];\nout = ranks( arr )\n\n// Missing values are placed last:\narr = [ null, 2, 2, 1, 4, 3, NaN, NaN ];\nout = ranks( arr )\n"
+RE_BASENAME,"var base = RE_BASENAME.exec( '/foo/bar/index.js' )[ 1 ]\n"
+RE_BASENAME_POSIX,"var base = RE_BASENAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '.' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '' )[ 1 ]\n"
+RE_BASENAME_WINDOWS,"var base = RE_BASENAME_WINDOWS.exec( '\\foo\\bar\\index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'C:\\foo\\bar\\.gitignore' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\file.pdf' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\bar\\file' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '.' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '' )[ 1 ]\n"
+RE_COLOR_HEXADECIMAL,"var bool = RE_COLOR_HEXADECIMAL.test( 'ffffff' )\nbool = RE_COLOR_HEXADECIMAL.test( '000' )\nbool = RE_COLOR_HEXADECIMAL.test( 'beep' )\n"
+RE_DECIMAL_NUMBER,"var bool = RE_DECIMAL_NUMBER.test( '1.234' )\nbool = RE_DECIMAL_NUMBER.test( '-1.234' )\nbool = RE_DECIMAL_NUMBER.test( '0.0' )\nbool = RE_DECIMAL_NUMBER.test( '.0' )\nbool = RE_DECIMAL_NUMBER.test( '0' )\nbool = RE_DECIMAL_NUMBER.test( 'beep' )\n\n// Create a RegExp to capture all decimal numbers:\nvar re = new RegExp( RE_DECIMAL_NUMBER.source, 'g' );\nvar str = '1.234 5.6, 7.8';\nvar out = str.match( re )\n"
+RE_DIRNAME,"var dir = RE_DIRNAME.exec( '/foo/bar/index.js' )[ 1 ]\n"
+RE_DIRNAME_POSIX,"var dir = RE_DIRNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '.' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '' )[ 1 ]\n"
+RE_DIRNAME_WINDOWS,"var dir = RE_DIRNAME_WINDOWS.exec( 'foo\\bar\\index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'C:\\foo\\bar\\.gitignore' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'foo\\file.pdf' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '\\foo\\bar\\file' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '' )[ 1 ]\n"
+RE_EOL,"var bool = RE_EOL.test( '\n' )\nbool = RE_EOL.test( '\r\n' )\nbool = RE_EOL.test( '\\r\\n' )\n"
+RE_EXTENDED_LENGTH_PATH,"var path = '\\\\?\\C:\\foo\\bar';\nvar bool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '\\\\?\\UNC\\server\\share';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = 'C:\\foo\\bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/c/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\n"
+RE_EXTNAME,"var dir = RE_EXTNAME.exec( '/foo/bar/index.js' )[ 1 ]\n"
+RE_EXTNAME_POSIX,"var ext = RE_EXTNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '.' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '' )[ 1 ]\n"
+RE_EXTNAME_WINDOWS,"var ext = RE_EXTNAME_WINDOWS.exec( 'C:\\foo\\bar\\index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'C:\\foo\\bar\\.gitignore' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'foo\\file.pdf' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '\\foo\\bar\\file' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'beep\\boop.' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '' )[ 1 ]\n"
+RE_FILENAME,"var f = '/foo/bar/index.js';\nvar parts = RE_FILENAME.exec( f ).slice()\n"
+RE_FILENAME_POSIX,"var parts = RE_FILENAME_POSIX.exec( '/foo/bar/index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( './foo/bar/.gitignore' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'foo/file.pdf' ).slice()\nparts = RE_FILENAME_POSIX.exec( '/foo/bar/file' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( '.' ).slice()\nparts = RE_FILENAME_POSIX.exec( './' ).slice()\nparts = RE_FILENAME_POSIX.exec( '' ).slice()\n"
+RE_FILENAME_WINDOWS,"var parts = RE_FILENAME_WINDOWS.exec( 'C:\\foo\\bar\\index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\foo\\bar\\.gitignore' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'foo\\file.pdf' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\foo\\bar\\file' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '.' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( './' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '' ).slice()\n"
+RE_FUNCTION_NAME,"function beep() { return 'boop'; };\nvar name = RE_FUNCTION_NAME.exec( beep.toString() )[ 1 ]\nname = RE_FUNCTION_NAME.exec( function () {} )[ 1 ]\n"
+RE_NATIVE_FUNCTION,"var bool = RE_NATIVE_FUNCTION.test( Date.toString() )\nbool = RE_NATIVE_FUNCTION.test( (function noop() {}).toString() )\n"
+RE_REGEXP,"var bool = RE_REGEXP.test( '/^beep$/' )\nbool = RE_REGEXP.test( '/boop' )\n\n// Escape regular expression strings:\nbool = RE_REGEXP.test( '/^\/([^\/]+)\/(.*)$/' )\nbool = RE_REGEXP.test( '/^\\/([^\\/]+)\\/(.*)$/' )\n"
+RE_UNC_PATH,"var path = '\\\\server\\share\\foo\\bar\\baz:a:b';\nvar bool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz::b';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz:a';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\share';\nbool = RE_UNC_PATH.test( path )\npath = 'beep boop \\\\server\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server';\nbool = RE_UNC_PATH.test( path )\npath = '\\';\nbool = RE_UNC_PATH.test( path )\npath = '';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz:a:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz::';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\baz:a:b:c';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\server\\share\\foo\\bar\\';\nbool = RE_UNC_PATH.test( path )\npath = '//server/share';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = 'foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = './foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/../bar';\nbool = RE_UNC_PATH.test( path )\n"
+RE_UTF16_SURROGATE_PAIR,"var bool = RE_UTF16_SURROGATE_PAIR.test( 'abc\uD800\uDC00def' )\nbool = RE_UTF16_SURROGATE_PAIR.test( 'abcdef' )\n"
+RE_UTF16_UNPAIRED_SURROGATE,"var bool = RE_UTF16_UNPAIRED_SURROGATE.test( 'abc' )\nbool = RE_UTF16_UNPAIRED_SURROGATE.test( '\uD800' )\n"
+RE_WHITESPACE,"var bool = RE_WHITESPACE.test( '\n' )\nbool = RE_WHITESPACE.test( ' ' )\nbool = RE_WHITESPACE.test( 'a' )\n"
+readDir,"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadDir( './beep/boop', onRead );\n"
+readFile,"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadFile( './beep/boop.js', onRead );\n"
+readFileList,"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nvar filepaths = [ './beep/boop.txt', './foo/bar.txt' ];\nreadFileList( filepaths, onRead );\n"
+readJSON,"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadJSON( './beep/boop.json', onRead );\n"
+readWASM,"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadWASM( './beep/boop.wasm', onRead );\n"
+real,"var z = new Complex128( 5.0, 3.0 );\nvar re = real( z )\n"
+realmax,"var m = realmax( 'float16' )\nm = realmax( 'float32' )\n"
+realmin,"var m = realmin( 'float16' )\nm = realmin( 'float32' )\n"
+reduce,"function sum( acc, v ) { return acc + v; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = reduce( arr, 0, sum )\n"
+reduceAsync,"\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'series': false };\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n"
+reduceRight,"function sum( acc, v ) {\n console.log( '%s: %d', acc, v );\n return acc + v;\n};\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = reduceRight( arr, 0, sum );\nout\n"
+reduceRightAsync,"\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'series': false };\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n"
+reFromString,"var re = reFromString( '/beep/' )\nre = reFromString( '/beep' )\n"
+reim,"var z = new Complex128( 5.0, 3.0 );\nvar out = reim( z )\n"
+removeFirst,"var out = removeFirst( 'beep' )\nout = removeFirst( 'Boop' )\n"
+removeLast,"var out = removeLast( 'beep' )\nout = removeLast( 'Boop' )\n"
+removePunctuation,"var str = 'Sun Tzu said: \"A leader leads by example not by force.\"';\nvar out = removePunctuation( str )\nstr = 'This function removes these characters: `{}[]:,!/<>().;~|?\'\"';\nout = removePunctuation( str )\n"
+removeUTF8BOM,"var out = removeUTF8BOM( '\ufeffbeep' )\n"
+removeWords,"var out = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ] )\n\n// Case-insensitive:\nout = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ], true )\n"
+rename,"function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nrename( './beep/boop.txt', './beep/foo.txt', done );\n"
+reorderArguments,"function foo( a, b, c ) { return [ a, b, c ]; };\nvar bar = reorderArguments( foo, [ 2, 0, 1 ] );\nvar out = bar( 1, 2, 3 )\n"
+repeat,"var out = repeat( 'a', 5 )\nout = repeat( '', 100 )\nout = repeat( 'beep', 0 )\n"
+replace,"\n// Standard usage:\nvar out = replace( 'beep', 'e', 'o' )\n\n// Replacer function:\nfunction replacer( match, p1 ) { return '/'+p1+'/'; };\nvar str = 'Oranges and lemons';\nout = replace( str, /([^\s]+)/gi, replacer )\n\n// Replace only first match:\nout = replace( 'beep', /e/, 'o' )\n"
+rescape,"var str = rescape( '[A-Z]*' )\n"
+resolveParentPath,"function onPath( error, path ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( path );\n }\n};\nresolveParentPath( 'package.json', onPath );\n"
+reverseArguments,"function foo( a, b, c ) { return [ a, b, c ]; };\nvar bar = reverseArguments( foo );\nvar out = bar( 1, 2, 3 )\n"
+reverseString,"var out = reverseString( 'foo' )\nout = reverseString( 'abcdef' )\n"
+reviveBasePRNG,"var str = JSON.stringify( base.random.mt19937 );\nvar r = parseJSON( str, reviveBasePRNG )\n"
+reviveBuffer,"var str = '{\"type\":\"Buffer\",\"data\":[5,3]}';\nvar buf = parseJSON( str, reviveBuffer )\n"
+reviveComplex,"var str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex )\n"
+reviveComplex64,"var str = '{\"type\":\"Complex64\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex64 )\n"
+reviveComplex128,"var str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex128 )\n"
+reviveError,"var str = '{\"type\":\"TypeError\",\"message\":\"beep\"}';\nvar err = JSON.parse( str, reviveError )\n"
+reviveTypedArray,"var str = '{\"type\":\"Float64Array\",\"data\":[5,3]}';\nvar arr = parseJSON( str, reviveTypedArray )\n"
+rpad,"var out = rpad( 'a', 5 )\nout = rpad( 'beep', 10, 'p' )\nout = rpad( 'beep', 12, 'boop' )\n"
+rtrim,"var out = rtrim( ' \t\t\n Beep \r\n\t ' )\n"
+safeintmax,"var m = safeintmax( 'float16' )\nm = safeintmax( 'float32' )\n"
+safeintmin,"var m = safeintmin( 'float16' )\nm = safeintmin( 'float32' )\n"
+sample,"var out = sample( 'abc' )\nout = sample( [ 3, 6, 9 ] )\nvar bool = ( out.length === 3 )\nout = sample( [ 3, null, NaN, 'abc', function(){} ] )\n\n// Set sample size:\nout = sample( [ 3, 6, 9 ], { 'size': 10 })\nout = sample( [ 0, 1 ], { 'size': 20 })\n\n// Draw without replacement:\nout = sample( [ 1, 2, 3, 4, 5, 6 ], { 'replace': false, 'size': 3 })\nout = sample( [ 0, 1 ], { 'replace': false })\n\n// Assigning non-uniform element probabilities:\nvar x = [ 1, 2, 3, 4, 5, 6 ];\nvar probs = [ 0.1, 0.1, 0.1, 0.1, 0.1, 0.5 ];\nout = sample( x, { 'probs': probs })\nout = sample( x, { 'probs': probs, 'size': 3, 'replace': false })\n"
+SAVOY_STOPWORDS_FIN,"var list = SAVOY_STOPWORDS_FIN()\n"
+SAVOY_STOPWORDS_FR,"var list = SAVOY_STOPWORDS_FR()\n"
+SAVOY_STOPWORDS_GER,"var list = SAVOY_STOPWORDS_GER()\n"
+SAVOY_STOPWORDS_IT,"var list = SAVOY_STOPWORDS_IT()\n"
+SAVOY_STOPWORDS_POR,"var list = SAVOY_STOPWORDS_POR()\n"
+SAVOY_STOPWORDS_SP,"var list = SAVOY_STOPWORDS_SP()\n"
+SAVOY_STOPWORDS_SWE,"var list = SAVOY_STOPWORDS_SWE()\n"
+SECONDS_IN_DAY,"var days = 3.14;\nvar secs = days * SECONDS_IN_DAY\n"
+SECONDS_IN_HOUR,"var hrs = 3.14;\nvar secs = hrs * SECONDS_IN_HOUR\n"
+SECONDS_IN_MINUTE,"var mins = 3.14;\nvar secs = mins * SECONDS_IN_MINUTE\n"
+SECONDS_IN_WEEK,"var wks = 3.14;\nvar secs = wks * SECONDS_IN_WEEK\n"
+secondsInMonth,"var num = secondsInMonth()\nnum = secondsInMonth( 2 )\nnum = secondsInMonth( 2, 2016 )\nnum = secondsInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = secondsInMonth( 'feb', 2016 )\nnum = secondsInMonth( 'february', 2016 )\n"
+secondsInYear,"var num = secondsInYear()\nnum = secondsInYear( 2016 )\nnum = secondsInYear( 2017 )\n"
+setConfigurableReadOnly,"var obj = {};\nsetConfigurableReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n"
+setConfigurableReadOnlyAccessor,"var obj = {};\nfunction getter() { return 'bar'; };\nsetConfigurableReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n"
+setConfigurableReadWriteAccessor,"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetConfigurableReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n"
+setConfigurableWriteOnlyAccessor,"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetConfigurableWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n"
+setMemoizedReadOnly,"var obj = {};\nfunction foo() { return 'bar'; };\nsetMemoizedReadOnly( obj, 'foo', foo );\nobj.foo\n"
+setNonEnumerableProperty,"var obj = {};\nsetNonEnumerableProperty( obj, 'foo', 'bar' );\nobj.foo\nobjectKeys( obj )\n"
+setNonEnumerableReadOnly,"var obj = {};\nsetNonEnumerableReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n"
+setNonEnumerableReadOnlyAccessor,"var obj = {};\nfunction getter() { return 'bar'; };\nsetNonEnumerableReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n"
+setNonEnumerableReadWriteAccessor,"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n"
+setNonEnumerableWriteOnlyAccessor,"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n"
+setReadOnly,"var obj = {};\nsetReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n"
+setReadOnlyAccessor,"var obj = {};\nfunction getter() { return 'bar'; };\nsetReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n"
+setReadWriteAccessor,"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n"
+setWriteOnlyAccessor,"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n"
+SharedArrayBuffer,"\n// Assuming an environment supports SharedArrayBuffers...\nvar buf = new SharedArrayBuffer( 5 )\n"
+shift,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar out = shift( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = shift( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = shift( arr )\n"
+shuffle,"var data = [ 1, 2, 3 ];\nvar out = shuffle( data )\nout = shuffle( data, { 'copy': 'none' });\nvar bool = ( data === out )\n"
+sizeOf,"var s = sizeOf( 'int8' )\ns = sizeOf( 'uint32' )\n"
+some,"var arr = [ 0, 0, 1, 2, 3 ];\nvar bool = some( arr, 3 )\n"
+someBy,"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, -3, 4, -1 ];\nvar bool = someBy( arr, 2, negative )\n"
+someByAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n"
+someByRight,"function negative( v ) { return ( v < 0 ); };\nvar arr = [ -1, 1, -2, 3, 4 ];\nvar bool = someByRight( arr, 2, negative )\n"
+someByRightAsync,"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n"
+SOTU,"var out = SOTU()\n\n// Retrieve addresses by one or more Presidents...\nvar opts = { 'name': 'Barack Obama' };\nout = SOTU( opts )\n\n// Retrieve addresses by one or more political parties...\nopts = { 'party': [ 'Democratic', 'Federalist' ] };\nout = SOTU( opts )\n\n// Retrieve addresses from one or more years...\nopts = { 'year': [ 2008, 2009, 2011 ] };\nout = SOTU( opts )\n\n// Retrieve addresses from a range of consecutive years...\nopts = { 'range': [ 2008, 2016 ] }\nout = SOTU( opts )\n"
+SPACHE_REVISED,"var list = SPACHE_REVISED()\n"
+SPAM_ASSASSIN,"var data = SPAM_ASSASSIN()\n"
+SparklineBase,"var sparkline = new SparklineBase()\n\n// Provide sparkline data at instantiation:\nvar data = [ 1, 2, 3 ];\nsparkline = new SparklineBase( data )\n"
+sparsearray2iterator,"var it = sparsearray2iterator( [ 1, , 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n"
+sparsearray2iteratorRight,"var it = sparsearray2iteratorRight( [ 1, 2, , 4 ] );\nvar v = it.next().value\nv = it.next().value\n"
+splitStream,"var s = splitStream();\ns.write( 'a\nb\nc' );\ns.end();\n"
+SQRT_EPS,"SQRT_EPS\n"
+SQRT_HALF,"SQRT_HALF\n"
+SQRT_HALF_PI,"SQRT_HALF_PI\n"
+SQRT_PHI,"SQRT_PHI\n"
+SQRT_PI,"SQRT_PI\n"
+SQRT_THREE,"SQRT_THREE\n"
+SQRT_TWO,"SQRT_TWO\n"
+SQRT_TWO_PI,"SQRT_TWO_PI\n"
+Stack,"var s = Stack();\ns.push( 'foo' ).push( 'bar' );\ns.length\ns.pop()\ns.length\ns.pop()\ns.length\n"
+startcase,"var out = startcase( 'beep boop' )\n"
+startsWith,"var bool = startsWith( 'Beep', 'Be' )\nbool = startsWith( 'Beep', 'ep' )\nbool = startsWith( 'Beep', 'ee', 1 )\nbool = startsWith( 'Beep', 'ee', -3 )\nbool = startsWith( 'Beep', '' )\n"
+STOPWORDS_EN,"var list = STOPWORDS_EN()\n"
+stridedarray2iterator,"var it = stridedarray2iterator( 2, [ 1, 2, 3, 4 ], -2, 3 );\nvar v = it.next().value\nv = it.next().value\n"
+stridedArrayStream,"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = stridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n"
+string2buffer,"var b = string2buffer( 'beep boop' )\nb = string2buffer( '7468697320697320612074c3a97374', 'hex' );\nb.toString()\n"
+sub2ind,"var d = [ 3, 3, 3 ];\nvar idx = sub2ind( d, 1, 2, 2 )\n"
+SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK,"var data = SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK()\n"
+SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK,"var data = SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK()\n"
+Symbol,"var s = ( Symbol ) ? Symbol( 'beep' ) : null\n"
+tabulate,"var collection = [ 'beep', 'boop', 'foo', 'beep' ];\nvar out = tabulate( collection )\n"
+tabulateBy,"function indicator( value ) { return value[ 0 ]; };\nvar collection = [ 'beep', 'boop', 'foo', 'beep' ];\nvar out = tabulateBy( collection, indicator )\n"
+tabulateByAsync,"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n"
+tic,"var t = tic()\n"
+timeit,"var code = 'var x = Math.pow( Math.random(), 3 );';\ncode += 'if ( x !== x ) {';\ncode += 'throw new Error( \'Something went wrong.\' );';\ncode += '}';\nfunction done( error, results ) {\n if ( error ) {\n throw error;\n }\n console.dir( results );\n};\ntimeit( code, done )\n"
+tmpdir,"var dir = tmpdir()\n"
+toc,"var start = tic();\nvar delta = toc( start )\n"
+tokenize,"var out = tokenize( 'Hello Mrs. Maple, could you call me back?' )\nout = tokenize( 'Hello World!', true )\n"
+transformStream,"var s = transformStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n"
+trim,"var out = trim( ' \t\t\n Beep \r\n\t ' )\n"
+trycatch,"function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nvar z = trycatch( x, -1.0 )\n"
+trycatchAsync,"function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n // process error...\n }\n console.log( result );\n};\ntrycatchAsync( x, 'boop', done )\n"
+tryFunction,"function fcn() { throw new Error( 'beep boop' ); };\nvar f = tryFunction( fcn );\nvar out = f();\nout.message\n"
+tryRequire,"var out = tryRequire( '_unknown_module_id_' )\n"
+trythen,"function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nfunction y() {\n return -1.0;\n};\nvar z = trythen( x, y )\n"
+trythenAsync,"function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ntrythenAsync( x, y, done )\n"
+ttest,"\n// One-sample t-test:\nvar rnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 5776 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nvar out = ttest( x )\n\n// Paired t-test:\nrnorm = base.random.normal.factory( 1.0, 2.0, { 'seed': 786 });\nx = new Array( 100 );\nvar y = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n y[ i ] = rnorm();\n}\nout = ttest( x, y )\n\n// Print formatted output:\nvar table = out.print()\n\n// Choose custom significance level:\narr = [ 2, 4, 3, 1, 0 ];\nout = ttest( arr, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\nvar arr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'alternative': 'less' });\ntable = out.print()\nout = ttest( arr, { 'alternative': 'greater' });\ntable = out.print()\n"
+ttest2,"\n// Student's sleep data:\nvar x = [ 0.7, -1.6, -0.2, -1.2, -0.1, 3.4, 3.7, 0.8, 0.0, 2.0 ];\nvar y = [ 1.9, 0.8, 1.1, 0.1, -0.1, 4.4, 5.5, 1.6, 4.6, 3.4 ];\nvar out = ttest2( x, y )\n\n// Print table output:\nvar table = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ttest2( x, y, { 'alpha': 0.1 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ttest2( x, y, { 'alternative': 'less' });\ntable = out.print()\nout = ttest2( x, y, { 'alternative': 'greater' });\ntable = out.print()\n\n// Run tests with equal variances assumption:\nx = [ 2, 3, 1, 4 ];\ny = [ 1, 2, 3, 1, 2, 5, 3, 4 ];\nout = ttest2( x, y, { 'variance': 'equal' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nvar rnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 3.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 1.0, 3.0 );\n}\nout = ttest2( x, y, { 'difference': 1.0, 'variance': 'equal' })\n"
+TWO_PI,"TWO_PI\n"
+typedarray,"var arr = typedarray()\narr = typedarray( 'float32' )\n"
+typedarray2json,"var arr = new Float64Array( 2 );\narr[ 0 ] = 5.0;\narr[ 1 ] = 3.0;\nvar json = typedarray2json( arr )\n"
+typedarrayComplexCtors,"var ctor = typedarrayComplexCtors( 'complex64' )\nctor = typedarrayComplexCtors( 'float32' )\n"
+typedarrayComplexDataTypes,"var out = typedarrayComplexDataTypes()\n"
+typedarrayCtors,"var ctor = typedarrayCtors( 'float64' )\nctor = typedarrayCtors( 'float' )\n"
+typedarrayDataTypes,"var out = typedarrayDataTypes()\n"
+typedarraypool,"var arr = typedarraypool()\narr = typedarraypool( 'float32' )\n"
+typemax,"var m = typemax( 'int8' )\nm = typemax( 'uint32' )\n"
+typemin,"var m = typemin( 'int8' )\nm = typemin( 'uint32' )\n"
+typeOf,"\n// Built-ins:\nvar t = typeOf( 'a' )\nt = typeOf( 5 )\nt = typeOf( NaN )\nt = typeOf( true )\nt = typeOf( false )\nt = typeOf( null )\nt = typeOf( undefined )\nt = typeOf( [] )\nt = typeOf( {} )\nt = typeOf( function noop() {} )\nt = typeOf( Symbol( 'beep' ) )\nt = typeOf( /.+/ )\nt = typeOf( new String( 'beep' ) )\nt = typeOf( new Number( 5 ) )\nt = typeOf( new Boolean( false ) )\nt = typeOf( new Array() )\nt = typeOf( new Object() )\nt = typeOf( new Int8Array( 10 ) )\nt = typeOf( new Uint8Array( 10 ) )\nt = typeOf( new Uint8ClampedArray( 10 ) )\nt = typeOf( new Int16Array( 10 ) )\nt = typeOf( new Uint16Array( 10 ) )\nt = typeOf( new Int32Array( 10 ) )\nt = typeOf( new Uint32Array( 10 ) )\nt = typeOf( new Float32Array( 10 ) )\nt = typeOf( new Float64Array( 10 ) )\nt = typeOf( new ArrayBuffer( 10 ) )\nt = typeOf( new Date() )\nt = typeOf( new RegExp( '.+' ) )\nt = typeOf( new Map() )\nt = typeOf( new Set() )\nt = typeOf( new WeakMap() )\nt = typeOf( new WeakSet() )\nt = typeOf( new Error( 'beep' ) )\nt = typeOf( new TypeError( 'beep' ) )\nt = typeOf( new SyntaxError( 'beep' ) )\nt = typeOf( new ReferenceError( 'beep' ) )\nt = typeOf( new URIError( 'beep' ) )\nt = typeOf( new RangeError( 'beep' ) )\nt = typeOf( new EvalError( 'beep' ) )\nt = typeOf( Math )\nt = typeOf( JSON )\n\n// Arguments object:\nfunction beep() { return arguments; };\nt = typeOf( beep() )\n\n// Node.js Buffer object:\nt = typeOf( new Buffer( 10 ) )\n\n// Custom constructor:\nfunction Person() { return this };\nt = typeOf( new Person() )\n\n// Anonymous constructor:\nvar Foo = function () { return this; };\nt = typeOf( new Foo() )\n"
+UINT8_MAX,"UINT8_MAX\n"
+UINT8_NUM_BYTES,"UINT8_NUM_BYTES\n"
+Uint8Array,"var arr = new Uint8Array()\n"
+Uint8ClampedArray,"var arr = new Uint8ClampedArray()\n"
+UINT16_MAX,"UINT16_MAX\n"
+UINT16_NUM_BYTES,"UINT16_NUM_BYTES\n"
+Uint16Array,"var arr = new Uint16Array()\n"
+UINT32_MAX,"UINT32_MAX\n"
+UINT32_NUM_BYTES,"UINT32_NUM_BYTES\n"
+Uint32Array,"var arr = new Uint32Array()\n"
+umask,"var mask = umask()\nmask = umask( { 'symbolic': true } )\n"
+uncapitalize,"var out = uncapitalize( 'Beep' )\nout = uncapitalize( 'bOOp' )\n"
+uncapitalizeKeys,"var obj = { 'AA': 1, 'BB': 2 };\nvar out = uncapitalizeKeys( obj )\n"
+uncurry,"function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nvar fcn = uncurry( addX );\nvar sum = fcn( 2, 3 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( x ) {\n return function add( y ) {\n return x + y;\n };\n};\nfcn = uncurry( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addX( x ) {\n this.x = x;\n return addY;\n};\nfunction addY( y ) {\n return this.x + y;\n};\nfcn = uncurry( addX, {} );\nsum = fcn( 2, 3 )\n"
+uncurryRight,"function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nvar fcn = uncurryRight( addX );\nvar sum = fcn( 3, 2 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( y ) {\n return function add( x ) {\n return x + y;\n };\n};\nfcn = uncurryRight( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addY( y ) {\n this.y = y;\n return addX;\n};\nfunction addX( x ) {\n return x + this.y;\n};\nfcn = uncurryRight( addY, {} );\nsum = fcn( 3, 2 )\n"
+UNICODE_MAX,"UNICODE_MAX\n"
+UNICODE_MAX_BMP,"UNICODE_MAX_BMP\n"
+UnicodeColumnChartSparkline,"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeColumnChartSparkline( data );\nchart.render()\n"
+UnicodeLineChartSparkline,"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeLineChartSparkline( data );\nchart.render()\n"
+UnicodeSparkline,"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeSparkline( data );\nchart.render()\nchart.type = 'line';\nchart.render()\n"
+UnicodeTristateChartSparkline,"var data = [ -1, 1, 0, 0, 1, -1, -1, 1 ];\nvar chart = new UnicodeTristateChartSparkline( data );\nchart.render()\n"
+UnicodeUpDownChartSparkline,"var data = [ -1, 1, 1, 1, 1, -1, -1, 1 ];\nvar chart = new UnicodeUpDownChartSparkline( data );\nchart.render()\n"
+UnicodeWinLossChartSparkline,"var data = [ -2, 1, 2, 2, 1, -1, -1, 1 ];\nvar chart = new UnicodeWinLossChartSparkline( data );\nchart.render()\n"
+unlink,"function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nunlink( './beep/boop.txt', done );\n"
+unshift,"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = unshift( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = unshift( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = unshift( arr, 2.0, 3.0 )\n"
+until,"function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nuntil( predicate, beep )\n"
+untilAsync,"function predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nuntilAsync( predicate, fcn, done )\n"
+untilEach,"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\nuntilEach( arr, predicate, logger )\n"
+untilEachRight,"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\nuntilEachRight( arr, predicate, logger )\n"
+unzip,"\n// Basic usage:\nvar arr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nvar out = unzip( arr )\n\n// Provide indices:\narr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nout = unzip( arr, [ 0, 2 ] )\n"
+uppercase,"var out = uppercase( 'bEEp' )\n"
+uppercaseKeys,"var obj = { 'a': 1, 'b': 2 };\nvar out = uppercaseKeys( obj )\n"
+US_STATES_ABBR,"var list = US_STATES_ABBR()\n"
+US_STATES_CAPITALS,"var list = US_STATES_CAPITALS()\n"
+US_STATES_CAPITALS_NAMES,"var out = US_STATES_CAPITALS_NAMES()\n"
+US_STATES_NAMES,"var list = US_STATES_NAMES()\n"
+US_STATES_NAMES_CAPITALS,"var out = US_STATES_NAMES_CAPITALS()\n"
+utf16ToUTF8Array,"var str = '☃';\nvar out = utf16ToUTF8Array( str )\n"
+vartest,"var x = [ 610, 610, 550, 590, 565, 570 ];\nvar y = [ 560, 550, 580, 550, 560, 590, 550, 590 ];\nvar out = vartest( x, y )\n\n// Print table output:\nvar table = out.print()\n"
+waterfall,"function foo( next ) { next( null, 'beep' ); };\nfunction bar( str, next ) { console.log( str ); next(); };\nfunction done( error ) { if ( error ) { throw error; } };\nvar fcns = [ foo, bar ];\nwaterfall( fcns, done );\n"
+whileAsync,"function predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nwhileAsync( predicate, fcn, done )\n"
+whileEach,"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\nwhileEach( arr, predicate, logger )\n"
+whileEachRight,"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\nwhileEachRight( arr, predicate, logger )\n"
+whilst,"function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nwhilst( predicate, beep )\n"
+writableProperties,"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = writableProperties( obj )\n"
+writablePropertiesIn,"var props = writablePropertiesIn( [] )\n"
+writablePropertyNames,"var obj = { 'a': 'b' };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = writablePropertyNames( obj )\n"
+writablePropertyNamesIn,"var obj = { 'a': 'b' };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = writablePropertyNamesIn( obj )\n"
+writablePropertySymbols,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = writablePropertySymbols( obj )\n"
+writablePropertySymbolsIn,"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = writablePropertySymbolsIn( obj )\n"
+writeFile,"function onWrite( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nwriteFile( './beep/boop.txt', 'beep boop', onWrite );\n"
+zip,"\n// Basic usage:\nvar out = zip( [ 1, 2 ], [ 'a', 'b' ] )\n\n// Turn off truncation:\nvar opts = { 'trunc': false };\nout = zip( [ 1, 2, 3 ], [ 'a', 'b' ], opts )\n"
+ztest,"\n// One-sample z-test:\nvar rnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 212 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nvar out = ztest( x, 2.0 )\n\n// Choose custom significance level and print output:\narr = [ 2, 4, 3, 1, 0 ];\nout = ztest( arr, 2.0, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\nvar arr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'alternative': 'less' })\nout = ztest( arr, 1.0, { 'alternative': 'greater' })\n"
+ztest2,"\n// Drawn from Normal(0,2):\nvar x = [ -0.21, 0.14, 1.65, 2.11, -1.86, -0.29, 1.48, 0.81, 0.86, 1.04 ];\n\n// Drawn from Normal(1,2):\nvar y = [ -1.53, -2.93, 2.34, -1.15, 2.7, -0.12, 4.22, 1.66, 3.43, 4.66 ];\nvar out = ztest2( x, y, 2.0, 2.0 )\n\n// Print table output:\nvar table = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ztest2( x, y, 2.0, 2.0, { 'alpha': 0.4 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'less' });\ntable = out.print()\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'greater' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nvar rnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 1.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 0.0, 2.0 );\n}\nout = ztest2( x, y, 1.0, 2.0, { 'difference': 2.0 })\n"
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/data/data.json b/lib/node_modules/@stdlib/repl/code-blocks/data/data.json
new file mode 100644
index 000000000000..f3c117f722c1
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/data/data.json
@@ -0,0 +1 @@
+{"AFINN_96":"var list = AFINN_96()\n","AFINN_111":"var list = AFINN_111()\n","alias2pkg":"var v = alias2pkg( 'base.sin' )\n","alias2related":"var v = alias2related( 'base.sin' )\n","aliases":"var o = aliases()\n","allocUnsafe":"var buf = allocUnsafe( 100 )\n","anova1":"var x = [1, 3, 5, 2, 4, 6, 8, 7, 10, 11, 12, 15];\nvar f = [\n'control', 'treatA', 'treatB', 'treatC', 'control',\n'treatA', 'treatB', 'treatC', 'control', 'treatA', 'treatB', 'treatC'\n];\nvar out = anova1( x, f )\n","ANSCOMBES_QUARTET":"var d = ANSCOMBES_QUARTET()\n","any":"var arr = [ 0, 0, 0, 0, 1 ];\nvar bool = any( arr )\n","anyBy":"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, 3, 4, -1 ];\nvar bool = anyBy( arr, negative )\n","anyByAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n","anyByRight":"function negative( v ) { return ( v < 0 ); };\nvar arr = [ -1, 1, 2, 3, 4 ];\nvar bool = anyByRight( arr, negative )\n","anyByRightAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n","APERY":"APERY\n","append":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = append( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = append( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 0 };\narr = append( arr, [ 1.0, 2.0 ] )\n","ARCH":"ARCH\n","argumentFunction":"var argn = argumentFunction( 1 );\nvar v = argn( 3.14, -3.14, 0.0 )\nv = argn( -1.0, -0.0, 1.0 )\nv = argn( 'beep', 'boop', 'bop' )\nv = argn( 'beep' )\n","ARGV":"var execPath = ARGV[ 0 ]\n","array":"\n// Create a 2x2 matrix:\nvar arr = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n","array2buffer":"var buf = array2buffer( [ 1, 2, 3, 4 ] )\n","array2iterator":"var it = array2iterator( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n","array2iteratorRight":"var it = array2iteratorRight( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n","ArrayBuffer":"var buf = new ArrayBuffer( 5 )\n","arraybuffer2buffer":"var ab = new ArrayBuffer( 10 )\nvar buf = arraybuffer2buffer( ab )\nvar len = buf.length\nbuf = arraybuffer2buffer( ab, 2, 6 )\nlen = buf.length\n","arrayCtors":"var ctor = arrayCtors( 'float64' )\nctor = arrayCtors( 'float' )\n","arrayDataType":"var arr = new Float64Array( 10 );\nvar dt = arrayDataType( arr )\ndt = arrayDataType( 'beep' )\n","arrayDataTypes":"var out = arrayDataTypes()\n","arrayMinDataType":"var dt = arrayMinDataType( 3.141592653589793 )\ndt = arrayMinDataType( 3 )\ndt = arrayMinDataType( -3 )\ndt = arrayMinDataType( '-3' )\n","arrayNextDataType":"var out = arrayNextDataType( 'float32' )\n","arrayPromotionRules":"var out = arrayPromotionRules( 'float32', 'int32' )\n","arraySafeCasts":"var out = arraySafeCasts( 'float32' )\n","arraySameKindCasts":"var out = arraySameKindCasts( 'float32' )\n","arrayShape":"var out = arrayShape( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] )\n","arrayStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = arrayStream( [ 1, 2, 3 ] );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","arrayview2iterator":"var it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3 );\nvar v = it.next().value\nv = it.next().value\n","arrayview2iteratorRight":"var it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3 );\nvar v = it.next().value\nv = it.next().value\n","AsyncIteratorSymbol":"var s = AsyncIteratorSymbol\n","bartlettTest":"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = bartlettTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = bartlettTest( arr, { 'groups': groups })\n","base.abs":"var y = base.abs( -1.0 )\ny = base.abs( 2.0 )\ny = base.abs( 0.0 )\ny = base.abs( -0.0 )\ny = base.abs( NaN )\n","base.abs2":"var y = base.abs2( -1.0 )\ny = base.abs2( 2.0 )\ny = base.abs2( 0.0 )\ny = base.abs2( -0.0 )\ny = base.abs2( NaN )\n","base.absdiff":"var d = base.absdiff( 2.0, 5.0 )\nd = base.absdiff( -1.0, 3.14 )\nd = base.absdiff( 10.1, -2.05 )\nd = base.absdiff( -0.0, 0.0 )\nd = base.absdiff( NaN, 5.0 )\nd = base.absdiff( PINF, NINF )\nd = base.absdiff( PINF, PINF )\n","base.absInt32":"var v = base.absInt32( -1|0 )\nv = base.absInt32( 2|0 )\nv = base.absInt32( 0|0 )\n","base.acos":"var y = base.acos( 1.0 )\ny = base.acos( 0.707 )\ny = base.acos( NaN )\n","base.acosh":"var y = base.acosh( 1.0 )\ny = base.acosh( 2.0 )\ny = base.acosh( NaN )\n","base.acoth":"var y = base.acoth( 2.0 )\ny = base.acoth( 0.0 )\ny = base.acoth( 0.5 )\ny = base.acoth( 1.0 )\ny = base.acoth( NaN )\n","base.acovercos":"var y = base.acovercos( -1.5 )\ny = base.acovercos( -0.0 )\n","base.acoversin":"var y = base.acoversin( 1.5 )\ny = base.acoversin( 0.0 )\n","base.ahavercos":"var y = base.ahavercos( 0.5 )\ny = base.ahavercos( 0.0 )\n","base.ahaversin":"var y = base.ahaversin( 0.5 )\ny = base.ahaversin( 0.0 )\n","base.asin":"var y = base.asin( 0.0 )\ny = base.asin( PI/2.0 )\ny = base.asin( -PI/6.0 )\ny = base.asin( NaN )\n","base.asinh":"var y = base.asinh( 0.0 )\ny = base.asinh( 2.0 )\ny = base.asinh( -2.0 )\ny = base.asinh( NaN )\ny = base.asinh( NINF )\ny = base.asinh( PINF )\n","base.atan":"var y = base.atan( 0.0 )\ny = base.atan( -PI/2.0 )\ny = base.atan( PI/2.0 )\ny = base.atan( NaN )\n","base.atan2":"var v = base.atan2( 2.0, 2.0 )\nv = base.atan2( 6.0, 2.0 )\nv = base.atan2( -1.0, -1.0 )\nv = base.atan2( 3.0, 0.0 )\nv = base.atan2( -2.0, 0.0 )\nv = base.atan2( 0.0, 0.0 )\nv = base.atan2( 3.0, NaN )\nv = base.atan2( NaN, 2.0 )\n","base.atanh":"var y = base.atanh( 0.0 )\ny = base.atanh( 0.9 )\ny = base.atanh( 1.0 )\ny = base.atanh( -1.0 )\ny = base.atanh( NaN )\n","base.avercos":"var y = base.avercos( -1.5 )\ny = base.avercos( -0.0 )\n","base.aversin":"var y = base.aversin( 1.5 )\ny = base.aversin( 0.0 )\n","base.bernoulli":"var y = base.bernoulli( 0 )\ny = base.bernoulli( 1 )\ny = base.bernoulli( 2 )\ny = base.bernoulli( 3 )\ny = base.bernoulli( 4 )\ny = base.bernoulli( 5 )\ny = base.bernoulli( 20 )\ny = base.bernoulli( 260 )\ny = base.bernoulli( 262 )\ny = base.bernoulli( NaN )\n","base.besselj0":"var y = base.besselj0( 0.0 )\ny = base.besselj0( 1.0 )\ny = base.besselj0( PINF )\ny = base.besselj0( NINF )\ny = base.besselj0( NaN )\n","base.besselj1":"var y = base.besselj1( 0.0 )\ny = base.besselj1( 1.0 )\ny = base.besselj1( PINF )\ny = base.besselj1( NINF )\ny = base.besselj1( NaN )\n","base.bessely0":"var y = base.bessely0( 0.0 )\ny = base.bessely0( 1.0 )\ny = base.bessely0( -1.0 )\ny = base.bessely0( PINF )\ny = base.bessely0( NINF )\ny = base.bessely0( NaN )\n","base.bessely1":"var y = base.bessely1( 0.0 )\ny = base.bessely1( 1.0 )\ny = base.bessely1( -1.0 )\ny = base.bessely1( PINF )\ny = base.bessely1( NINF )\ny = base.bessely1( NaN )\n","base.beta":"var v = base.beta( 0.0, 0.5 )\nv = base.beta( 1.0, 1.0 )\nv = base.beta( -1.0, 2.0 )\nv = base.beta( 5.0, 0.2 )\nv = base.beta( 4.0, 1.0 )\nv = base.beta( NaN, 2.0 )\n","base.betainc":"var y = base.betainc( 0.5, 2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, 2.0, false )\ny = base.betainc( 0.2, 1.0, 2.0 )\ny = base.betainc( 0.2, 1.0, 2.0, true, true )\ny = base.betainc( NaN, 1.0, 1.0 )\ny = base.betainc( 0.8, NaN, 1.0 )\ny = base.betainc( 0.8, 1.0, NaN )\ny = base.betainc( 1.5, 1.0, 1.0 )\ny = base.betainc( -0.5, 1.0, 1.0 )\ny = base.betainc( 0.5, -2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, -2.0 )\n","base.betaincinv":"var y = base.betaincinv( 0.2, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0, true )\ny = base.betaincinv( 0.4, 1.0, 6.0 )\ny = base.betaincinv( 0.8, 1.0, 6.0 )\ny = base.betaincinv( NaN, 1.0, 1.0 )\ny = base.betaincinv( 0.5, NaN, 1.0 )\ny = base.betaincinv( 0.5, 1.0, NaN )\ny = base.betaincinv( 1.2, 1.0, 1.0 )\ny = base.betaincinv( -0.5, 1.0, 1.0 )\ny = base.betaincinv( 0.5, -2.0, 2.0 )\ny = base.betaincinv( 0.5, 0.0, 2.0 )\ny = base.betaincinv( 0.5, 2.0, -2.0 )\ny = base.betaincinv( 0.5, 2.0, 0.0 )\n","base.betaln":"var v = base.betaln( 0.0, 0.0 )\nv = base.betaln( 1.0, 1.0 )\nv = base.betaln( -1.0, 2.0 )\nv = base.betaln( 5.0, 0.2 )\nv = base.betaln( 4.0, 1.0 )\nv = base.betaln( NaN, 2.0 )\n","base.binet":"var y = base.binet( 0.0 )\ny = base.binet( 1.0 )\ny = base.binet( 2.0 )\ny = base.binet( 3.0 )\ny = base.binet( 4.0 )\ny = base.binet( 5.0 )\ny = base.binet( NaN )\n","base.binomcoef":"var v = base.binomcoef( 8, 2 )\nv = base.binomcoef( 0, 0 )\nv = base.binomcoef( -4, 2 )\nv = base.binomcoef( 5, 3 )\nv = base.binomcoef( NaN, 3 )\nv = base.binomcoef( 5, NaN )\nv = base.binomcoef( NaN, NaN )\n","base.binomcoefln":"var v = base.binomcoefln( 8, 2 )\nv = base.binomcoefln( 0, 0 )\nv = base.binomcoefln( -4, 2 )\nv = base.binomcoefln( 88, 3 )\nv = base.binomcoefln( NaN, 3 )\nv = base.binomcoefln( 5, NaN )\nv = base.binomcoefln( NaN, NaN )\n","base.boxcox":"var v = base.boxcox( 1.0, 2.5 )\nv = base.boxcox( 4.0, 2.5 )\nv = base.boxcox( 10.0, 2.5 )\nv = base.boxcox( 2.0, 0.0 )\nv = base.boxcox( -1.0, 2.5 )\nv = base.boxcox( 0.0, -1.0 )\n","base.boxcox1p":"var v = base.boxcox1p( 1.0, 2.5 )\nv = base.boxcox1p( 4.0, 2.5 )\nv = base.boxcox1p( 10.0, 2.5 )\nv = base.boxcox1p( 2.0, 0.0 )\nv = base.boxcox1p( -1.0, 2.5 )\nv = base.boxcox1p( 0.0, -1.0 )\nv = base.boxcox1p( -1.0, -1.0 )\n","base.boxcox1pinv":"var v = base.boxcox1pinv( 1.0, 2.5 )\nv = base.boxcox1pinv( 4.0, 2.5 )\nv = base.boxcox1pinv( 10.0, 2.5 )\nv = base.boxcox1pinv( 2.0, 0.0 )\nv = base.boxcox1pinv( -1.0, 2.5 )\nv = base.boxcox1pinv( 0.0, -1.0 )\nv = base.boxcox1pinv( 1.0, NaN )\nv = base.boxcox1pinv( NaN, 3.1 )\n","base.boxcoxinv":"var v = base.boxcoxinv( 1.0, 2.5 )\nv = base.boxcoxinv( 4.0, 2.5 )\nv = base.boxcoxinv( 10.0, 2.5 )\nv = base.boxcoxinv( 2.0, 0.0 )\nv = base.boxcoxinv( -1.0, 2.5 )\nv = base.boxcoxinv( 0.0, -1.0 )\nv = base.boxcoxinv( 1.0, NaN )\nv = base.boxcoxinv( NaN, 3.1 )\n","base.cabs":"var y = base.cabs( 5.0, 3.0 )\n","base.cabs2":"var y = base.cabs2( 5.0, 3.0 )\n","base.cadd":"var y = base.cadd( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nvar out = new Float32Array( 2 );\ny = base.cadd( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( y === out )\n","base.cbrt":"var y = base.cbrt( 64.0 )\ny = base.cbrt( 27.0 )\ny = base.cbrt( 0.0 )\ny = base.cbrt( -0.0 )\ny = base.cbrt( -9.0 )\ny = base.cbrt( NaN )\n","base.cceil":"var out = base.cceil( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cceil( out, 5.5, 3.3 )\nvar bool = ( v === out )\n","base.cceiln":"var out = base.cceiln( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cceiln( out, 5.555, -3.333, -2 )\nvar bool = ( v === out )\n","base.ccis":"var y = base.ccis( 0.0, 0.0 )\nvar y = base.ccis( 1.0, 0.0 )\nvar out = new Float64Array( 2 );\nvar v = base.ccis( out, 1.0, 0.0 )\nvar bool = ( v === out )\n","base.cdiv":"var y = base.cdiv( -13.0, -1.0, -2.0, 1.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cdiv( out, -13.0, -1.0, -2.0, 1.0 )\nvar bool = ( v === out )\n","base.ceil":"var y = base.ceil( 3.14 )\ny = base.ceil( -4.2 )\ny = base.ceil( -4.6 )\ny = base.ceil( 9.5 )\ny = base.ceil( -0.0 )\n","base.ceil2":"var y = base.ceil2( 3.14 )\ny = base.ceil2( -4.2 )\ny = base.ceil2( -4.6 )\ny = base.ceil2( 9.5 )\ny = base.ceil2( 13.0 )\ny = base.ceil2( -13.0 )\ny = base.ceil2( -0.0 )\n","base.ceil10":"var y = base.ceil10( 3.14 )\ny = base.ceil10( -4.2 )\ny = base.ceil10( -4.6 )\ny = base.ceil10( 9.5 )\ny = base.ceil10( 13.0 )\ny = base.ceil10( -13.0 )\ny = base.ceil10( -0.0 )\n","base.ceilb":"\n// Round to 4 decimal places:\nvar y = base.ceilb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.ceilb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward positive infinity:\ny = base.ceilb( 5.0, 1, 2 )\n","base.ceiln":"\n// Round to 2 decimal places:\nvar y = base.ceiln( 3.14159, -2 )\n\n// If `n = 0`, standard round toward positive infinity behavior:\ny = base.ceiln( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.ceiln( 12368.0, 3 )\n","base.ceilsd":"var y = base.ceilsd( 3.14159, 5 )\ny = base.ceilsd( 3.14159, 1 )\ny = base.ceilsd( 12368.0, 2 )\ny = base.ceilsd( 0.0313, 2, 2 )\n","base.cexp":"var y = base.cexp( 0.0, 0.0 )\ny = base.cexp( 0.0, 1.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cexp( out, 0.0, 1.0 )\nvar bool = ( v === out )\n","base.cflipsign":"var out = base.cflipsign( -4.2, 5.5, -9 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cflipsign( out, -4.2, 5.5, 8 )\nvar bool = ( v === out )\n","base.cfloor":"var out = base.cfloor( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cfloor( out, 5.5, 3.3 )\nvar bool = ( v === out )\n","base.cfloorn":"var out = base.cfloorn( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cfloorn( out, 5.555, -3.333, -2 )\nvar bool = ( v === out )\n","base.cinv":"var y = base.cinv( 2.0, 4.0 )\nvar out = new Float64Array( 2 );\nvar v = base.cinv( out, 2.0, 4.0 )\nvar bool = ( v === out )\n","base.clamp":"var y = base.clamp( 3.14, 0.0, 5.0 )\ny = base.clamp( -3.14, 0.0, 5.0 )\ny = base.clamp( 3.14, 0.0, 3.0 )\ny = base.clamp( -0.0, 0.0, 5.0 )\ny = base.clamp( 0.0, -3.14, -0.0 )\ny = base.clamp( NaN, 0.0, 5.0 )\n","base.cmul":"var out = base.cmul( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\nvar v = base.cmul( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( v === out )\n","base.cneg":"var out = base.cneg( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cneg( out, -4.2, 5.5 )\nvar bool = ( v === out )\n","base.continuedFraction":"\n// Continued fraction for (e-1)^(-1):\nfunction closure() {\n var i = 0;\n return function() {\n i += 1;\n return [ i, i ];\n };\n};\nvar gen = closure();\nvar out = base.continuedFraction( gen )\n\n// Using an ES6 generator:\nfunction* generator() {\n var i = 0;\n while ( true ) {\n i += 1;\n yield [ i, i ];\n }\n};\ngen = generator();\nout = base.continuedFraction( gen )\n\n// Set options:\nout = base.continuedFraction( generator(), { 'keep': true } )\nout = base.continuedFraction( generator(), { 'maxIter': 10 } )\nout = base.continuedFraction( generator(), { 'tolerance': 1e-1 } )\n","base.copysign":"var z = base.copysign( -3.14, 10.0 )\nz = base.copysign( 3.14, -1.0 )\nz = base.copysign( 1.0, -0.0 )\nz = base.copysign( -3.14, -0.0 )\nz = base.copysign( -0.0, 1.0 )\n","base.cos":"var y = base.cos( 0.0 )\ny = base.cos( PI/4.0 )\ny = base.cos( -PI/6.0 )\ny = base.cos( NaN )\n","base.cosh":"var y = base.cosh( 0.0 )\ny = base.cosh( 2.0 )\ny = base.cosh( -2.0 )\ny = base.cosh( NaN )\n","base.cosm1":"var y = base.cosm1( 0.0 )\ny = base.cosm1( PI/4.0 )\ny = base.cosm1( -PI/6.0 )\ny = base.cosm1( NaN )\n","base.cospi":"var y = base.cospi( 0.0 )\ny = base.cospi( 0.5 )\ny = base.cospi( 0.1 )\ny = base.cospi( NaN )\n","base.covercos":"var y = base.covercos( 3.14 )\ny = base.covercos( -4.2 )\ny = base.covercos( -4.6 )\ny = base.covercos( 9.5 )\ny = base.covercos( -0.0 )\n","base.coversin":"var y = base.coversin( 3.14 )\ny = base.coversin( -4.2 )\ny = base.coversin( -4.6 )\ny = base.coversin( 9.5 )\ny = base.coversin( -0.0 )\n","base.cphase":"var phi = base.cphase( 5.0, 3.0 )\n","base.cpolar":"var out = base.cpolar( 5.0, 3.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cpolar( out, 5.0, 3.0 )\nvar bool = ( v === out )\n","base.cround":"var out = base.cround( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.cround( out, 5.5, 3.3 )\nvar bool = ( v === out )\n","base.croundn":"var out = base.croundn( 5.555, -3.336, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.croundn( out, 5.555, -3.336, -2 )\nvar bool = ( v === out )\n","base.csignum":"var out = base.csignum( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.csignum( out, -4.2, 5.5 )\nvar bool = ( v === out )\n","base.csub":"var out = base.csub( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.csub( out, 5.0, 3.0, -2.0, 1.0 )\nvar bool = ( v === out )\n","base.dasum":"\n// Standard usage:\nvar x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nvar sum = base.dasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.dasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.dasum( N, x1, stride )\n","base.daxpy":"\n// Standard usage:\nvar x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nvar alpha = 5.0;\nbase.daxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\ny = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nbase.daxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.daxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n","base.dcopy":"\n// Standard usage:\nvar x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.dcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar N = base.floor( x.length / 2 );\nbase.dcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.dcopy( N, x1, -2, y1, 1 )\ny0\n","base.deg2rad":"var r = base.deg2rad( 90.0 )\nr = base.deg2rad( -45.0 )\nr = base.deg2rad( NaN )\n","base.digamma":"var y = base.digamma( -2.5 )\ny = base.digamma( 1.0 )\ny = base.digamma( 10.0 )\ny = base.digamma( NaN )\ny = base.digamma( -1.0 )\n","base.diracDelta":"var y = base.diracDelta( 3.14 )\ny = base.diracDelta( 0.0 )\n","base.dists.arcsine.Arcsine":"var arcsine = base.dists.arcsine.Arcsine( 0.0, 1.0 );\narcsine.a\narcsine.b\narcsine.entropy\narcsine.kurtosis\narcsine.mean\narcsine.median\narcsine.mode\narcsine.skewness\narcsine.stdev\narcsine.variance\narcsine.cdf( 0.8 )\narcsine.logcdf( 0.8 )\narcsine.logpdf( 0.4 )\narcsine.pdf( 0.8 )\narcsine.quantile( 0.8 )\n","base.dists.arcsine.cdf":"var y = base.dists.arcsine.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.cdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.cdf( 2.0, 1.0, 0.0 )\n","base.dists.arcsine.entropy":"var v = base.dists.arcsine.entropy( 0.0, 1.0 )\nv = base.dists.arcsine.entropy( 4.0, 12.0 )\nv = base.dists.arcsine.entropy( 2.0, 8.0 )\n","base.dists.arcsine.kurtosis":"var v = base.dists.arcsine.kurtosis( 0.0, 1.0 )\nv = base.dists.arcsine.kurtosis( 4.0, 12.0 )\nv = base.dists.arcsine.kurtosis( 2.0, 8.0 )\n","base.dists.arcsine.logcdf":"var y = base.dists.arcsine.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logcdf( 2.0, 1.0, 0.0 )\n","base.dists.arcsine.logpdf":"var y = base.dists.arcsine.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logpdf( 2.0, 3.0, 1.0 )\n","base.dists.arcsine.mean":"var v = base.dists.arcsine.mean( 0.0, 1.0 )\nv = base.dists.arcsine.mean( 4.0, 12.0 )\nv = base.dists.arcsine.mean( 2.0, 8.0 )\n","base.dists.arcsine.median":"var v = base.dists.arcsine.median( 0.0, 1.0 )\nv = base.dists.arcsine.median( 4.0, 12.0 )\nv = base.dists.arcsine.median( 2.0, 8.0 )\n","base.dists.arcsine.mode":"var v = base.dists.arcsine.mode( 0.0, 1.0 )\nv = base.dists.arcsine.mode( 4.0, 12.0 )\nv = base.dists.arcsine.mode( 2.0, 8.0 )\n","base.dists.arcsine.pdf":"var y = base.dists.arcsine.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.pdf( 2.0, 3.0, 1.0 )\n","base.dists.arcsine.quantile":"var y = base.dists.arcsine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.arcsine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, 0.0, NaN )\ny = base.dists.arcsine.quantile( 0.5, 2.0, 1.0 )\n","base.dists.arcsine.skewness":"var v = base.dists.arcsine.skewness( 0.0, 1.0 )\nv = base.dists.arcsine.skewness( 4.0, 12.0 )\nv = base.dists.arcsine.skewness( 2.0, 8.0 )\n","base.dists.arcsine.stdev":"var v = base.dists.arcsine.stdev( 0.0, 1.0 )\nv = base.dists.arcsine.stdev( 4.0, 12.0 )\nv = base.dists.arcsine.stdev( 2.0, 8.0 )\n","base.dists.arcsine.variance":"var v = base.dists.arcsine.variance( 0.0, 1.0 )\nv = base.dists.arcsine.variance( 4.0, 12.0 )\nv = base.dists.arcsine.variance( 2.0, 8.0 )\n","base.dists.bernoulli.Bernoulli":"var bernoulli = base.dists.bernoulli.Bernoulli( 0.6 );\nbernoulli.p\nbernoulli.entropy\nbernoulli.kurtosis\nbernoulli.mean\nbernoulli.median\nbernoulli.skewness\nbernoulli.stdev\nbernoulli.variance\nbernoulli.cdf( 0.5 )\nbernoulli.mgf( 3.0 )\nbernoulli.pmf( 0.0 )\nbernoulli.quantile( 0.7 )\n","base.dists.bernoulli.cdf":"var y = base.dists.bernoulli.cdf( 0.5, 0.5 )\ny = base.dists.bernoulli.cdf( 0.8, 0.1 )\ny = base.dists.bernoulli.cdf( -1.0, 0.4 )\ny = base.dists.bernoulli.cdf( 1.5, 0.4 )\ny = base.dists.bernoulli.cdf( NaN, 0.5 )\ny = base.dists.bernoulli.cdf( 0.0, NaN )\n\n// Invalid probability:\ny = base.dists.bernoulli.cdf( 2.0, 1.4 )\n","base.dists.bernoulli.entropy":"var v = base.dists.bernoulli.entropy( 0.1 )\nv = base.dists.bernoulli.entropy( 0.5 )\n","base.dists.bernoulli.kurtosis":"var v = base.dists.bernoulli.kurtosis( 0.1 )\nv = base.dists.bernoulli.kurtosis( 0.5 )\n","base.dists.bernoulli.mean":"var v = base.dists.bernoulli.mean( 0.1 )\nv = base.dists.bernoulli.mean( 0.5 )\n","base.dists.bernoulli.median":"var v = base.dists.bernoulli.median( 0.1 )\nv = base.dists.bernoulli.median( 0.8 )\n","base.dists.bernoulli.mgf":"var y = base.dists.bernoulli.mgf( 0.2, 0.5 )\ny = base.dists.bernoulli.mgf( 0.4, 0.5 )\ny = base.dists.bernoulli.mgf( NaN, 0.0 )\ny = base.dists.bernoulli.mgf( 0.0, NaN )\ny = base.dists.bernoulli.mgf( -2.0, -1.0 )\ny = base.dists.bernoulli.mgf( 0.2, 2.0 )\n","base.dists.bernoulli.mode":"var v = base.dists.bernoulli.mode( 0.1 )\nv = base.dists.bernoulli.mode( 0.8 )\n","base.dists.bernoulli.pmf":"var y = base.dists.bernoulli.pmf( 1.0, 0.3 )\ny = base.dists.bernoulli.pmf( 0.0, 0.7 )\ny = base.dists.bernoulli.pmf( -1.0, 0.5 )\ny = base.dists.bernoulli.pmf( 0.0, NaN )\ny = base.dists.bernoulli.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.bernoulli.pmf( 0.0, 1.5 )\n","base.dists.bernoulli.quantile":"var y = base.dists.bernoulli.quantile( 0.8, 0.4 )\ny = base.dists.bernoulli.quantile( 0.5, 0.4 )\ny = base.dists.bernoulli.quantile( 0.9, 0.1 )\ny = base.dists.bernoulli.quantile( -0.2, 0.1 )\ny = base.dists.bernoulli.quantile( NaN, 0.8 )\ny = base.dists.bernoulli.quantile( 0.4, NaN )\ny = base.dists.bernoulli.quantile( 0.5, -1.0 )\ny = base.dists.bernoulli.quantile( 0.5, 1.5 )\n","base.dists.bernoulli.skewness":"var v = base.dists.bernoulli.skewness( 0.1 )\nv = base.dists.bernoulli.skewness( 0.5 )\n","base.dists.bernoulli.stdev":"var v = base.dists.bernoulli.stdev( 0.1 )\nv = base.dists.bernoulli.stdev( 0.5 )\n","base.dists.bernoulli.variance":"var v = base.dists.bernoulli.variance( 0.1 )\nv = base.dists.bernoulli.variance( 0.5 )\n","base.dists.beta.Beta":"var beta = base.dists.beta.Beta( 1.0, 1.0 );\nbeta.alpha\nbeta.beta\nbeta.entropy\nbeta.kurtosis\nbeta.mean\nbeta.median\nbeta.mode\nbeta.skewness\nbeta.stdev\nbeta.variance\nbeta.cdf( 0.8 )\nbeta.logcdf( 0.8 )\nbeta.logpdf( 1.0 )\nbeta.mgf( 3.14 )\nbeta.pdf( 1.0 )\nbeta.quantile( 0.8 )\n","base.dists.beta.cdf":"var y = base.dists.beta.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.cdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.cdf( 0.0, 1.0, NaN )\n","base.dists.beta.entropy":"var v = base.dists.beta.entropy( 1.0, 1.0 )\nv = base.dists.beta.entropy( 4.0, 12.0 )\nv = base.dists.beta.entropy( 8.0, 2.0 )\nv = base.dists.beta.entropy( 1.0, -0.1 )\nv = base.dists.beta.entropy( -0.1, 1.0 )\nv = base.dists.beta.entropy( 2.0, NaN )\nv = base.dists.beta.entropy( NaN, 2.0 )\n","base.dists.beta.kurtosis":"var v = base.dists.beta.kurtosis( 1.0, 1.0 )\nv = base.dists.beta.kurtosis( 4.0, 12.0 )\nv = base.dists.beta.kurtosis( 8.0, 2.0 )\nv = base.dists.beta.kurtosis( 1.0, -0.1 )\nv = base.dists.beta.kurtosis( -0.1, 1.0 )\nv = base.dists.beta.kurtosis( 2.0, NaN )\nv = base.dists.beta.kurtosis( NaN, 2.0 )\n","base.dists.beta.logcdf":"var y = base.dists.beta.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.logcdf( 0.0, 1.0, NaN )\n","base.dists.beta.logpdf":"var y = base.dists.beta.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 1.0, NaN )\n","base.dists.beta.mean":"var v = base.dists.beta.mean( 1.0, 1.0 )\nv = base.dists.beta.mean( 4.0, 12.0 )\nv = base.dists.beta.mean( 8.0, 2.0 )\n","base.dists.beta.median":"var v = base.dists.beta.median( 1.0, 1.0 )\nv = base.dists.beta.median( 4.0, 12.0 )\nv = base.dists.beta.median( 8.0, 2.0 )\nv = base.dists.beta.median( 1.0, -0.1 )\nv = base.dists.beta.median( -0.1, 1.0 )\nv = base.dists.beta.median( 2.0, NaN )\nv = base.dists.beta.median( NaN, 2.0 )\n","base.dists.beta.mgf":"var y = base.dists.beta.mgf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.mgf( 3.0, 2.0, 2.0 )\ny = base.dists.beta.mgf( -0.8, 4.0, 4.0 )\ny = base.dists.beta.mgf( NaN, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.0, NaN, 1.0 )\ny = base.dists.beta.mgf( 0.0, 1.0, NaN )\ny = base.dists.beta.mgf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.mgf( 2.0, 0.5, 0.0 )\n","base.dists.beta.mode":"var v = base.dists.beta.mode( 4.0, 12.0 )\nv = base.dists.beta.mode( 8.0, 2.0 )\nv = base.dists.beta.mode( 1.0, 1.0 )\n","base.dists.beta.pdf":"var y = base.dists.beta.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.pdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.pdf( 0.5, 1.0, NaN )\n","base.dists.beta.quantile":"var y = base.dists.beta.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.beta.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.beta.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.beta.quantile( NaN, 1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, NaN, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, NaN )\ny = base.dists.beta.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, -1.0 )\n","base.dists.beta.skewness":"var v = base.dists.beta.skewness( 1.0, 1.0 )\nv = base.dists.beta.skewness( 4.0, 12.0 )\nv = base.dists.beta.skewness( 8.0, 2.0 )\nv = base.dists.beta.skewness( 1.0, -0.1 )\nv = base.dists.beta.skewness( -0.1, 1.0 )\nv = base.dists.beta.skewness( 2.0, NaN )\nv = base.dists.beta.skewness( NaN, 2.0 )\n","base.dists.beta.stdev":"var v = base.dists.beta.stdev( 1.0, 1.0 )\nv = base.dists.beta.stdev( 4.0, 12.0 )\nv = base.dists.beta.stdev( 8.0, 2.0 )\nv = base.dists.beta.stdev( 1.0, -0.1 )\nv = base.dists.beta.stdev( -0.1, 1.0 )\nv = base.dists.beta.stdev( 2.0, NaN )\nv = base.dists.beta.stdev( NaN, 2.0 )\n","base.dists.beta.variance":"var v = base.dists.beta.variance( 1.0, 1.0 )\nv = base.dists.beta.variance( 4.0, 12.0 )\nv = base.dists.beta.variance( 8.0, 2.0 )\nv = base.dists.beta.variance( 1.0, -0.1 )\nv = base.dists.beta.variance( -0.1, 1.0 )\nv = base.dists.beta.variance( 2.0, NaN )\nv = base.dists.beta.variance( NaN, 2.0 )\n","base.dists.betaprime.BetaPrime":"var betaprime = base.dists.betaprime.BetaPrime( 6.0, 5.0 );\nbetaprime.alpha\nbetaprime.beta\nbetaprime.kurtosis\nbetaprime.mean\nbetaprime.mode\nbetaprime.skewness\nbetaprime.stdev\nbetaprime.variance\nbetaprime.cdf( 0.8 )\nbetaprime.logcdf( 0.8 )\nbetaprime.logpdf( 1.0 )\nbetaprime.pdf( 1.0 )\nbetaprime.quantile( 0.8 )\n","base.dists.betaprime.cdf":"var y = base.dists.betaprime.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.cdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, 1.0, NaN )\n","base.dists.betaprime.kurtosis":"var v = base.dists.betaprime.kurtosis( 2.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 4.0, 12.0 )\nv = base.dists.betaprime.kurtosis( 8.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 1.0, 2.8 )\nv = base.dists.betaprime.kurtosis( 1.0, -0.1 )\nv = base.dists.betaprime.kurtosis( -0.1, 5.0 )\nv = base.dists.betaprime.kurtosis( 2.0, NaN )\nv = base.dists.betaprime.kurtosis( NaN, 6.0 )\n","base.dists.betaprime.logcdf":"var y = base.dists.betaprime.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, 1.0, NaN )\n","base.dists.betaprime.logpdf":"var y = base.dists.betaprime.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 1.0, NaN )\n","base.dists.betaprime.mean":"var v = base.dists.betaprime.mean( 1.0, 2.0 )\nv = base.dists.betaprime.mean( 4.0, 12.0 )\nv = base.dists.betaprime.mean( 8.0, 2.0 )\n","base.dists.betaprime.mode":"var v = base.dists.betaprime.mode( 1.0, 2.0 )\nv = base.dists.betaprime.mode( 4.0, 12.0 )\nv = base.dists.betaprime.mode( 8.0, 2.0 )\n","base.dists.betaprime.pdf":"var y = base.dists.betaprime.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.pdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 1.0, NaN )\n","base.dists.betaprime.quantile":"var y = base.dists.betaprime.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.betaprime.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, NaN )\ny = base.dists.betaprime.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, -1.0 )\n","base.dists.betaprime.skewness":"var v = base.dists.betaprime.skewness( 2.0, 4.0 )\nv = base.dists.betaprime.skewness( 4.0, 12.0 )\nv = base.dists.betaprime.skewness( 8.0, 4.0 )\nv = base.dists.betaprime.skewness( 1.0, 2.8 )\nv = base.dists.betaprime.skewness( 1.0, -0.1 )\nv = base.dists.betaprime.skewness( -0.1, 4.0 )\nv = base.dists.betaprime.skewness( 2.0, NaN )\nv = base.dists.betaprime.skewness( NaN, 4.0 )\n","base.dists.betaprime.stdev":"var v = base.dists.betaprime.stdev( 1.0, 2.5 )\nv = base.dists.betaprime.stdev( 4.0, 12.0 )\nv = base.dists.betaprime.stdev( 8.0, 2.5 )\nv = base.dists.betaprime.stdev( 8.0, 1.0 )\nv = base.dists.betaprime.stdev( 1.0, -0.1 )\nv = base.dists.betaprime.stdev( -0.1, 3.0 )\nv = base.dists.betaprime.stdev( 2.0, NaN )\nv = base.dists.betaprime.stdev( NaN, 3.0 )\n","base.dists.betaprime.variance":"var v = base.dists.betaprime.variance( 1.0, 2.5 )\nv = base.dists.betaprime.variance( 4.0, 12.0 )\nv = base.dists.betaprime.variance( 8.0, 2.5 )\nv = base.dists.betaprime.variance( 8.0, 1.0 )\nv = base.dists.betaprime.variance( 1.0, -0.1 )\nv = base.dists.betaprime.variance( -0.1, 3.0 )\nv = base.dists.betaprime.variance( 2.0, NaN )\nv = base.dists.betaprime.variance( NaN, 3.0 )\n","base.dists.binomial.Binomial":"var binomial = base.dists.binomial.Binomial( 8, 0.5 );\nbinomial.n\nbinomial.p\nbinomial.kurtosis\nbinomial.mean\nbinomial.median\nbinomial.mode\nbinomial.skewness\nbinomial.stdev\nbinomial.variance\nbinomial.cdf( 2.9 )\nbinomial.logpmf( 3.0 )\nbinomial.mgf( 0.2 )\nbinomial.pmf( 3.0 )\nbinomial.quantile( 0.8 )\n","base.dists.binomial.cdf":"var y = base.dists.binomial.cdf( 3.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 21.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 5.0, 10, 0.4 )\ny = base.dists.binomial.cdf( 0.0, 10, 0.4 )\ny = base.dists.binomial.cdf( NaN, 20, 0.5 )\ny = base.dists.binomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.cdf( 0.0, 20, NaN )\ny = base.dists.binomial.cdf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.binomial.cdf( 2.0, 20, 1.5 )\n","base.dists.binomial.entropy":"var v = base.dists.binomial.entropy( 100, 0.1 )\nv = base.dists.binomial.entropy( 20, 0.5 )\nv = base.dists.binomial.entropy( 10.3, 0.5 )\nv = base.dists.binomial.entropy( 20, 1.1 )\nv = base.dists.binomial.entropy( 20, NaN )\n","base.dists.binomial.kurtosis":"var v = base.dists.binomial.kurtosis( 100, 0.1 )\nv = base.dists.binomial.kurtosis( 20, 0.5 )\nv = base.dists.binomial.kurtosis( 10.3, 0.5 )\nv = base.dists.binomial.kurtosis( 20, 1.1 )\nv = base.dists.binomial.kurtosis( 20, NaN )\n","base.dists.binomial.logpmf":"var y = base.dists.binomial.logpmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( NaN, 20, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, 20, NaN )\ny = base.dists.binomial.logpmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.logpmf( 2.0, 20, 1.5 )\n","base.dists.binomial.mean":"var v = base.dists.binomial.mean( 100, 0.1 )\nv = base.dists.binomial.mean( 20, 0.5 )\nv = base.dists.binomial.mean( 10.3, 0.5 )\nv = base.dists.binomial.mean( 20, 1.1 )\nv = base.dists.binomial.mean( 20, NaN )\n","base.dists.binomial.median":"var v = base.dists.binomial.median( 100, 0.1 )\nv = base.dists.binomial.median( 20, 0.5 )\nv = base.dists.binomial.median( 10.3, 0.5 )\nv = base.dists.binomial.median( 20, 1.1 )\nv = base.dists.binomial.median( 20, NaN )\n","base.dists.binomial.mgf":"var y = base.dists.binomial.mgf( 0.5, 20, 0.2 )\ny = base.dists.binomial.mgf( 5.0, 20, 0.2 )\ny = base.dists.binomial.mgf( 0.9, 10, 0.4 )\ny = base.dists.binomial.mgf( 0.0, 10, 0.4 )\ny = base.dists.binomial.mgf( NaN, 20, 0.5 )\ny = base.dists.binomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.mgf( 0.0, 20, NaN )\ny = base.dists.binomial.mgf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.mgf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.mgf( 2.0, 20, -1.0 )\ny = base.dists.binomial.mgf( 2.0, 20, 1.5 )\n","base.dists.binomial.mode":"var v = base.dists.binomial.mode( 100, 0.1 )\nv = base.dists.binomial.mode( 20, 0.5 )\nv = base.dists.binomial.mode( 10.3, 0.5 )\nv = base.dists.binomial.mode( 20, 1.1 )\nv = base.dists.binomial.mode( 20, NaN )\n","base.dists.binomial.pmf":"var y = base.dists.binomial.pmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.pmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.pmf( NaN, 20, 0.5 )\ny = base.dists.binomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.pmf( 0.0, 20, NaN )\ny = base.dists.binomial.pmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.pmf( 2.0, 20, 1.5 )\n","base.dists.binomial.quantile":"var y = base.dists.binomial.quantile( 0.4, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.8, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.5, 10, 0.4 )\ny = base.dists.binomial.quantile( 0.0, 10, 0.4 )\ny = base.dists.binomial.quantile( 1.0, 10, 0.4 )\ny = base.dists.binomial.quantile( NaN, 20, 0.5 )\ny = base.dists.binomial.quantile( 0.2, NaN, 0.5 )\ny = base.dists.binomial.quantile( 0.2, 20, NaN )\ny = base.dists.binomial.quantile( 0.5, 1.5, 0.5 )\ny = base.dists.binomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.binomial.quantile( 0.5, 20, -1.0 )\ny = base.dists.binomial.quantile( 0.5, 20, 1.5 )\n","base.dists.binomial.skewness":"var v = base.dists.binomial.skewness( 100, 0.1 )\nv = base.dists.binomial.skewness( 20, 0.5 )\nv = base.dists.binomial.skewness( 10.3, 0.5 )\nv = base.dists.binomial.skewness( 20, 1.1 )\nv = base.dists.binomial.skewness( 20, NaN )\n","base.dists.binomial.stdev":"var v = base.dists.binomial.stdev( 100, 0.1 )\nv = base.dists.binomial.stdev( 20, 0.5 )\nv = base.dists.binomial.stdev( 10.3, 0.5 )\nv = base.dists.binomial.stdev( 20, 1.1 )\nv = base.dists.binomial.stdev( 20, NaN )\n","base.dists.binomial.variance":"var v = base.dists.binomial.variance( 100, 0.1 )\nv = base.dists.binomial.variance( 20, 0.5 )\nv = base.dists.binomial.variance( 10.3, 0.5 )\nv = base.dists.binomial.variance( 20, 1.1 )\nv = base.dists.binomial.variance( 20, NaN )\n","base.dists.cauchy.Cauchy":"var cauchy = base.dists.cauchy.Cauchy( 0.0, 1.0 );\ncauchy.x0\ncauchy.gamma\ncauchy.entropy\ncauchy.median\ncauchy.mode\ncauchy.cdf( 0.8 )\ncauchy.logcdf( 1.0 )\ncauchy.logpdf( 1.0 )\ncauchy.pdf( 1.0 )\ncauchy.quantile( 0.8 )\n","base.dists.cauchy.cdf":"var y = base.dists.cauchy.cdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.cdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.cdf( 1.0, NaN, 3.0 )\n","base.dists.cauchy.entropy":"var v = base.dists.cauchy.entropy( 10.0, 7.0 )\nv = base.dists.cauchy.entropy( 22.0, 0.5 )\nv = base.dists.cauchy.entropy( 10.3, -0.5 )\n","base.dists.cauchy.logcdf":"var y = base.dists.cauchy.logcdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.logcdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.logcdf( 1.0, NaN, 3.0 )\n","base.dists.cauchy.logpdf":"var y = base.dists.cauchy.logpdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.logpdf( 2.0, 1.0, -2.0 )\n","base.dists.cauchy.median":"var v = base.dists.cauchy.median( 10.0, 5.0 )\nv = base.dists.cauchy.median( 7.0, 0.5 )\nv = base.dists.cauchy.median( 10.3, -0.5 )\n","base.dists.cauchy.mode":"var v = base.dists.cauchy.mode( 10.0, 5.0 )\nv = base.dists.cauchy.mode( 7.0, 0.5 )\nv = base.dists.cauchy.mode( 10.3, -0.5 )\n","base.dists.cauchy.pdf":"var y = base.dists.cauchy.pdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.pdf( 2.0, 1.0, -2.0 )\n","base.dists.cauchy.quantile":"var y = base.dists.cauchy.quantile( 0.3, 2.0, 2.0 )\ny = base.dists.cauchy.quantile( 0.8, 10, 2.0 )\ny = base.dists.cauchy.quantile( 0.1, 10.0, 2.0 )\ny = base.dists.cauchy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.quantile( 0.5, 0.0, -1.0 )\n","base.dists.chi.cdf":"var y = base.dists.chi.cdf( 2.0, 3.0 )\ny = base.dists.chi.cdf( 1.0, 0.5 )\ny = base.dists.chi.cdf( -1.0, 4.0 )\ny = base.dists.chi.cdf( NaN, 1.0 )\ny = base.dists.chi.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.cdf( 2.0, 0.0 )\ny = base.dists.chi.cdf( -2.0, 0.0 )\ny = base.dists.chi.cdf( 0.0, 0.0 )\n","base.dists.chi.Chi":"var chi = base.dists.chi.Chi( 6.0 );\nchi.k\nchi.entropy\nchi.kurtosis\nchi.mean\nchi.mode\nchi.skewness\nchi.stdev\nchi.variance\nchi.cdf( 1.0 )\nchi.logpdf( 1.5 )\nchi.pdf( 1.5 )\nchi.quantile( 0.5 )\n","base.dists.chi.entropy":"var v = base.dists.chi.entropy( 11.0 )\nv = base.dists.chi.entropy( 1.5 )\n","base.dists.chi.kurtosis":"var v = base.dists.chi.kurtosis( 9.0 )\nv = base.dists.chi.kurtosis( 1.5 )\n","base.dists.chi.logpdf":"var y = base.dists.chi.logpdf( 0.3, 4.0 )\ny = base.dists.chi.logpdf( 0.7, 0.7 )\ny = base.dists.chi.logpdf( -1.0, 0.5 )\ny = base.dists.chi.logpdf( 0.0, NaN )\ny = base.dists.chi.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.logpdf( 0.0, 0.0, 2.0 )\n","base.dists.chi.mean":"var v = base.dists.chi.mean( 11.0 )\nv = base.dists.chi.mean( 4.5 )\n","base.dists.chi.mode":"var v = base.dists.chi.mode( 11.0 )\nv = base.dists.chi.mode( 1.5 )\n","base.dists.chi.pdf":"var y = base.dists.chi.pdf( 0.3, 4.0 )\ny = base.dists.chi.pdf( 0.7, 0.7 )\ny = base.dists.chi.pdf( -1.0, 0.5 )\ny = base.dists.chi.pdf( 0.0, NaN )\ny = base.dists.chi.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.pdf( 0.0, 0.0, 2.0 )\n","base.dists.chi.quantile":"var y = base.dists.chi.quantile( 0.8, 1.0 )\ny = base.dists.chi.quantile( 0.5, 4.0 )\ny = base.dists.chi.quantile( 0.8, 0.1 )\ny = base.dists.chi.quantile( -0.2, 0.5 )\ny = base.dists.chi.quantile( 1.1, 0.5 )\ny = base.dists.chi.quantile( NaN, 1.0 )\ny = base.dists.chi.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.quantile( 0.3, 0.0 )\ny = base.dists.chi.quantile( 0.9, 0.0 )\n","base.dists.chi.skewness":"var v = base.dists.chi.skewness( 11.0 )\nv = base.dists.chi.skewness( 1.5 )\n","base.dists.chi.stdev":"var v = base.dists.chi.stdev( 11.0 )\nv = base.dists.chi.stdev( 1.5 )\n","base.dists.chi.variance":"var v = base.dists.chi.variance( 11.0 )\nv = base.dists.chi.variance( 1.5 )\n","base.dists.chisquare.cdf":"var y = base.dists.chisquare.cdf( 2.0, 3.0 )\ny = base.dists.chisquare.cdf( 1.0, 0.5 )\ny = base.dists.chisquare.cdf( -1.0, 4.0 )\ny = base.dists.chisquare.cdf( NaN, 1.0 )\ny = base.dists.chisquare.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.cdf( 2.0, 0.0 )\ny = base.dists.chisquare.cdf( -2.0, 0.0 )\ny = base.dists.chisquare.cdf( 0.0, 0.0 )\n","base.dists.chisquare.ChiSquare":"var chisquare = base.dists.chisquare.ChiSquare( 6.0 );\nchisquare.k\nchisquare.entropy\nchisquare.kurtosis\nchisquare.mean\nchisquare.mode\nchisquare.skewness\nchisquare.stdev\nchisquare.variance\nchisquare.cdf( 3.0 )\nchisquare.mgf( 0.2 )\nchisquare.pdf( 1.5 )\nchisquare.quantile( 0.5 )\n","base.dists.chisquare.entropy":"var v = base.dists.chisquare.entropy( 11.0 )\nv = base.dists.chisquare.entropy( 1.5 )\n","base.dists.chisquare.kurtosis":"var v = base.dists.chisquare.kurtosis( 9.0 )\nv = base.dists.chisquare.kurtosis( 1.5 )\n","base.dists.chisquare.logpdf":"var y = base.dists.chisquare.logpdf( 0.3, 4.0 )\ny = base.dists.chisquare.logpdf( 0.7, 0.7 )\ny = base.dists.chisquare.logpdf( -1.0, 0.5 )\ny = base.dists.chisquare.logpdf( 0.0, NaN )\ny = base.dists.chisquare.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.logpdf( 0.0, 0.0, 2.0 )\n","base.dists.chisquare.mean":"var v = base.dists.chisquare.mean( 11.0 )\nv = base.dists.chisquare.mean( 4.5 )\n","base.dists.chisquare.mode":"var v = base.dists.chisquare.mode( 11.0 )\nv = base.dists.chisquare.mode( 1.5 )\n","base.dists.chisquare.pdf":"var y = base.dists.chisquare.pdf( 0.3, 4.0 )\ny = base.dists.chisquare.pdf( 0.7, 0.7 )\ny = base.dists.chisquare.pdf( -1.0, 0.5 )\ny = base.dists.chisquare.pdf( 0.0, NaN )\ny = base.dists.chisquare.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.pdf( 0.0, 0.0, 2.0 )\n","base.dists.chisquare.quantile":"var y = base.dists.chisquare.quantile( 0.8, 1.0 )\ny = base.dists.chisquare.quantile( 0.5, 4.0 )\ny = base.dists.chisquare.quantile( 0.8, 0.1 )\ny = base.dists.chisquare.quantile( -0.2, 0.5 )\ny = base.dists.chisquare.quantile( 1.1, 0.5 )\ny = base.dists.chisquare.quantile( NaN, 1.0 )\ny = base.dists.chisquare.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.quantile( 0.3, 0.0 )\ny = base.dists.chisquare.quantile( 0.9, 0.0 )\n","base.dists.chisquare.skewness":"var v = base.dists.chisquare.skewness( 11.0 )\nv = base.dists.chisquare.skewness( 1.5 )\n","base.dists.chisquare.stdev":"var v = base.dists.chisquare.stdev( 11.0 )\nv = base.dists.chisquare.stdev( 1.5 )\n","base.dists.chisquare.variance":"var v = base.dists.chisquare.variance( 11.0 )\nv = base.dists.chisquare.variance( 1.5 )\n","base.dists.cosine.cdf":"var y = base.dists.cosine.cdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.cdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.cdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 10.0, 8.0, 0.0 )\n","base.dists.cosine.Cosine":"var cosine = base.dists.cosine.Cosine( -2.0, 3.0 );\ncosine.mu\ncosine.s\ncosine.kurtosis\ncosine.mean\ncosine.median\ncosine.mode\ncosine.skewness\ncosine.stdev\ncosine.variance\ncosine.cdf( 0.5 )\ncosine.logcdf( 0.5 )\ncosine.logpdf( -1.0 )\ncosine.mgf( 0.2 )\ncosine.pdf( -2.0 )\ncosine.quantile( 0.9 )\n","base.dists.cosine.kurtosis":"var y = base.dists.cosine.kurtosis( 0.0, 1.0 )\ny = base.dists.cosine.kurtosis( 4.0, 2.0 )\ny = base.dists.cosine.kurtosis( NaN, 1.0 )\ny = base.dists.cosine.kurtosis( 0.0, NaN )\ny = base.dists.cosine.kurtosis( 0.0, 0.0 )\n","base.dists.cosine.logcdf":"var y = base.dists.cosine.logcdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.logcdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.logcdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.logcdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.logcdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 10.0, 8.0, 0.0 )\n","base.dists.cosine.logpdf":"var y = base.dists.cosine.logpdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logpdf( -1.0, 2.0, 4.0 )\ny = base.dists.cosine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.cosine.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logpdf( 8.0, 8.0, 0.0 )\n","base.dists.cosine.mean":"var y = base.dists.cosine.mean( 0.0, 1.0 )\ny = base.dists.cosine.mean( 4.0, 2.0 )\ny = base.dists.cosine.mean( NaN, 1.0 )\ny = base.dists.cosine.mean( 0.0, NaN )\ny = base.dists.cosine.mean( 0.0, 0.0 )\n","base.dists.cosine.median":"var y = base.dists.cosine.median( 0.0, 1.0 )\ny = base.dists.cosine.median( 4.0, 2.0 )\ny = base.dists.cosine.median( NaN, 1.0 )\ny = base.dists.cosine.median( 0.0, NaN )\ny = base.dists.cosine.median( 0.0, 0.0 )\n","base.dists.cosine.mgf":"var y = base.dists.cosine.mgf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.mgf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.mgf( 0.5, 0.0, NaN )\ny = base.dists.cosine.mgf( 0.5, NaN, 1.0 )\ny = base.dists.cosine.mgf( NaN, 0.0, 1.0 )\n","base.dists.cosine.mode":"var y = base.dists.cosine.mode( 0.0, 1.0 )\ny = base.dists.cosine.mode( 4.0, 2.0 )\ny = base.dists.cosine.mode( NaN, 1.0 )\ny = base.dists.cosine.mode( 0.0, NaN )\ny = base.dists.cosine.mode( 0.0, 0.0 )\n","base.dists.cosine.pdf":"var y = base.dists.cosine.pdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.pdf( 2.4, 4.0, 2.0 )\ny = base.dists.cosine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.cosine.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.pdf( 8.0, 8.0, 0.0 )\n","base.dists.cosine.quantile":"var y = base.dists.cosine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.cosine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cosine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cosine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cosine.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.quantile( 0.5, 0.0, -1.0 )\n","base.dists.cosine.skewness":"var y = base.dists.cosine.skewness( 0.0, 1.0 )\ny = base.dists.cosine.skewness( 4.0, 2.0 )\ny = base.dists.cosine.skewness( NaN, 1.0 )\ny = base.dists.cosine.skewness( 0.0, NaN )\ny = base.dists.cosine.skewness( 0.0, 0.0 )\n","base.dists.cosine.stdev":"var y = base.dists.cosine.stdev( 0.0, 1.0 )\ny = base.dists.cosine.stdev( 4.0, 2.0 )\ny = base.dists.cosine.stdev( NaN, 1.0 )\ny = base.dists.cosine.stdev( 0.0, NaN )\ny = base.dists.cosine.stdev( 0.0, 0.0 )\n","base.dists.cosine.variance":"var y = base.dists.cosine.variance( 0.0, 1.0 )\ny = base.dists.cosine.variance( 4.0, 2.0 )\ny = base.dists.cosine.variance( NaN, 1.0 )\ny = base.dists.cosine.variance( 0.0, NaN )\ny = base.dists.cosine.variance( 0.0, 0.0 )\n","base.dists.degenerate.cdf":"var y = base.dists.degenerate.cdf( 2.0, 3.0 )\ny = base.dists.degenerate.cdf( 4.0, 3.0 )\ny = base.dists.degenerate.cdf( 3.0, 3.0 )\ny = base.dists.degenerate.cdf( NaN, 0.0 )\ny = base.dists.degenerate.cdf( 0.0, NaN )\n","base.dists.degenerate.Degenerate":"var degenerate = base.dists.degenerate.Degenerate( 2.0 );\ndegenerate.mu\ndegenerate.entropy\ndegenerate.mean\ndegenerate.mode\ndegenerate.median\ndegenerate.stdev\ndegenerate.variance\ndegenerate.cdf( 0.5 )\ndegenerate.logcdf( 2.5 )\ndegenerate.logpdf( 0.5 )\ndegenerate.logpmf( 2.5 )\ndegenerate.mgf( 0.2 )\ndegenerate.pdf( 2.0 )\ndegenerate.pmf( 2.0 )\ndegenerate.quantile( 0.7 )\n","base.dists.degenerate.entropy":"var v = base.dists.degenerate.entropy( 20.0 )\nv = base.dists.degenerate.entropy( -10.0 )\n","base.dists.degenerate.logcdf":"var y = base.dists.degenerate.logcdf( 2.0, 3.0 )\ny = base.dists.degenerate.logcdf( 4.0, 3.0 )\ny = base.dists.degenerate.logcdf( 3.0, 3.0 )\ny = base.dists.degenerate.logcdf( NaN, 0.0 )\ny = base.dists.degenerate.logcdf( 0.0, NaN )\n","base.dists.degenerate.logpdf":"var y = base.dists.degenerate.logpdf( 2.0, 3.0 )\ny = base.dists.degenerate.logpdf( 3.0, 3.0 )\ny = base.dists.degenerate.logpdf( NaN, 0.0 )\ny = base.dists.degenerate.logpdf( 0.0, NaN )\n","base.dists.degenerate.logpmf":"var y = base.dists.degenerate.logpmf( 2.0, 3.0 )\ny = base.dists.degenerate.logpmf( 3.0, 3.0 )\ny = base.dists.degenerate.logpmf( NaN, 0.0 )\ny = base.dists.degenerate.logpmf( 0.0, NaN )\n","base.dists.degenerate.mean":"var v = base.dists.degenerate.mean( 20.0 )\nv = base.dists.degenerate.mean( -10.0 )\n","base.dists.degenerate.median":"var v = base.dists.degenerate.median( 20.0 )\nv = base.dists.degenerate.median( -10.0 )\n","base.dists.degenerate.mgf":"var y = base.dists.degenerate.mgf( 1.0, 1.0 )\ny = base.dists.degenerate.mgf( 2.0, 3.0 )\ny = base.dists.degenerate.mgf( NaN, 0.0 )\ny = base.dists.degenerate.mgf( 0.0, NaN )\n","base.dists.degenerate.mode":"var v = base.dists.degenerate.mode( 20.0 )\nv = base.dists.degenerate.mode( -10.0 )\n","base.dists.degenerate.pdf":"var y = base.dists.degenerate.pdf( 2.0, 3.0 )\ny = base.dists.degenerate.pdf( 3.0, 3.0 )\ny = base.dists.degenerate.pdf( NaN, 0.0 )\ny = base.dists.degenerate.pdf( 0.0, NaN )\n","base.dists.degenerate.pmf":"var y = base.dists.degenerate.pmf( 2.0, 3.0 )\ny = base.dists.degenerate.pmf( 3.0, 3.0 )\ny = base.dists.degenerate.pmf( NaN, 0.0 )\ny = base.dists.degenerate.pmf( 0.0, NaN )\n","base.dists.degenerate.quantile":"var y = base.dists.degenerate.quantile( 0.5, 2.0 )\ny = base.dists.degenerate.quantile( 0.9, 4.0 )\ny = base.dists.degenerate.quantile( 1.1, 0.0 )\ny = base.dists.degenerate.quantile( -0.2, 0.0 )\ny = base.dists.degenerate.quantile( NaN, 0.0 )\ny = base.dists.degenerate.quantile( 0.0, NaN )\n","base.dists.degenerate.stdev":"var v = base.dists.degenerate.stdev( 20.0 )\nv = base.dists.degenerate.stdev( -10.0 )\n","base.dists.degenerate.variance":"var v = base.dists.degenerate.variance( 20.0 )\nv = base.dists.degenerate.variance( -10.0 )\n","base.dists.discreteUniform.cdf":"var y = base.dists.discreteUniform.cdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.cdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.cdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.cdf( 2.0, 1, 0 )\n","base.dists.discreteUniform.DiscreteUniform":"var discreteUniform = base.dists.discreteUniform.DiscreteUniform( -2, 2 );\ndiscreteUniform.a\ndiscreteUniform.b\ndiscreteUniform.entropy\ndiscreteUniform.kurtosis\ndiscreteUniform.mean\ndiscreteUniform.median\ndiscreteUniform.skewness\ndiscreteUniform.stdev\ndiscreteUniform.variance\ndiscreteUniform.cdf( 0.8 )\ndiscreteUniform.logcdf( 0.5 )\ndiscreteUniform.logpmf( 1.0 )\ndiscreteUniform.mgf( 0.8 )\ndiscreteUniform.pmf( 0.0 )\ndiscreteUniform.quantile( 0.8 )\n","base.dists.discreteUniform.kurtosis":"var v = base.dists.discreteUniform.kurtosis( 0, 1 )\nv = base.dists.discreteUniform.kurtosis( 4, 12 )\nv = base.dists.discreteUniform.kurtosis( -4, 8 )\n","base.dists.discreteUniform.logcdf":"var y = base.dists.discreteUniform.logcdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.logcdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.logcdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logcdf( 2.0, 1, 0 )\n","base.dists.discreteUniform.logpmf":"var y = base.dists.discreteUniform.logpmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.logpmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logpmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.logpmf( 2.0, 1, 2.4 )\n","base.dists.discreteUniform.mean":"var v = base.dists.discreteUniform.mean( -2, 2 )\nv = base.dists.discreteUniform.mean( 4, 12 )\nv = base.dists.discreteUniform.mean( 2, 8 )\n","base.dists.discreteUniform.median":"var v = base.dists.discreteUniform.median( -2, 2 )\nv = base.dists.discreteUniform.median( 4, 12 )\nv = base.dists.discreteUniform.median( 2, 8 )\n","base.dists.discreteUniform.mgf":"var y = base.dists.discreteUniform.mgf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.mgf( -0.2, 0, 4 )\ny = base.dists.discreteUniform.mgf( 2.0, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.5, 3, 2 )\ny = base.dists.discreteUniform.mgf( NaN, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, 0, NaN )\n","base.dists.discreteUniform.pmf":"var y = base.dists.discreteUniform.pmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.pmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.pmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.pmf( 2.0, 1, 2.4 )\n","base.dists.discreteUniform.quantile":"var y = base.dists.discreteUniform.quantile( 0.8, 0, 1 )\ny = base.dists.discreteUniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.discreteUniform.quantile( 1.1, 0, 4 )\ny = base.dists.discreteUniform.quantile( -0.2, 0, 4 )\ny = base.dists.discreteUniform.quantile( NaN, -2, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, NaN, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, -2, NaN )\ny = base.dists.discreteUniform.quantile( 0.5, 2, 1 )\n","base.dists.discreteUniform.skewness":"var v = base.dists.discreteUniform.skewness( -2, 2 )\nv = base.dists.discreteUniform.skewness( 4, 12 )\nv = base.dists.discreteUniform.skewness( 2, 8 )\n","base.dists.discreteUniform.stdev":"var v = base.dists.discreteUniform.stdev( 0, 1 )\nv = base.dists.discreteUniform.stdev( 4, 12 )\nv = base.dists.discreteUniform.stdev( 2, 8 )\n","base.dists.discreteUniform.variance":"var v = base.dists.discreteUniform.variance( 0, 1 )\nv = base.dists.discreteUniform.variance( 4, 12 )\nv = base.dists.discreteUniform.variance( 2, 8 )\n","base.dists.erlang.cdf":"var y = base.dists.erlang.cdf( 2.0, 1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 3, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 2.5, 1.0 )\ny = base.dists.erlang.cdf( -1.0, 2, 2.0 )\ny = base.dists.erlang.cdf( PINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NaN, 0, 1.0 )\ny = base.dists.erlang.cdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.cdf( 0.0, 0, NaN )\ny = base.dists.erlang.cdf( 2.0, -1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 1, -1.0 )\n","base.dists.erlang.entropy":"var v = base.dists.erlang.entropy( 1, 1.0 )\nv = base.dists.erlang.entropy( 4, 12.0 )\nv = base.dists.erlang.entropy( 8, 2.0 )\n","base.dists.erlang.Erlang":"var erlang = base.dists.erlang.Erlang( 6, 5.0 );\nerlang.k\nerlang.lambda\nerlang.entropy\nerlang.kurtosis\nerlang.mean\nerlang.mode\nerlang.skewness\nerlang.stdev\nerlang.variance\nerlang.cdf( 3.0 )\nerlang.logpdf( 3.0 )\nerlang.mgf( -0.5 )\nerlang.pdf( 3.0 )\nerlang.quantile( 0.8 )\n","base.dists.erlang.kurtosis":"var v = base.dists.erlang.kurtosis( 1, 1.0 )\nv = base.dists.erlang.kurtosis( 4, 12.0 )\nv = base.dists.erlang.kurtosis( 8, 2.0 )\n","base.dists.erlang.logpdf":"var y = base.dists.erlang.logpdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.logpdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.logpdf( NaN, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, 1, NaN )\ny = base.dists.erlang.logpdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, -1.0 )\n","base.dists.erlang.mean":"var v = base.dists.erlang.mean( 1, 1.0 )\nv = base.dists.erlang.mean( 4, 12.0 )\nv = base.dists.erlang.mean( 8, 2.0 )\n","base.dists.erlang.mgf":"var y = base.dists.erlang.mgf( 0.3, 1, 1.0 )\ny = base.dists.erlang.mgf( 2.0, 2, 3.0 )\ny = base.dists.erlang.mgf( -1.0, 2, 2.0 )\ny = base.dists.erlang.mgf( NaN, 1, 1.0 )\ny = base.dists.erlang.mgf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.mgf( 0.0, 1, NaN )\ny = base.dists.erlang.mgf( 0.2, -2, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 0.5, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 1, 0.0 )\ny = base.dists.erlang.mgf( 0.2, 1, -5.0 )\n","base.dists.erlang.mode":"var v = base.dists.erlang.mode( 1, 1.0 )\nv = base.dists.erlang.mode( 4, 12.0 )\nv = base.dists.erlang.mode( 8, 2.0 )\n","base.dists.erlang.pdf":"var y = base.dists.erlang.pdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.pdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.pdf( NaN, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.pdf( 0.0, 1, NaN )\ny = base.dists.erlang.pdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.pdf( 2.0, 1, -1.0 )\n","base.dists.erlang.quantile":"var y = base.dists.erlang.quantile( 0.8, 2, 1.0 )\ny = base.dists.erlang.quantile( 0.5, 4, 2.0 )\ny = base.dists.erlang.quantile( 1.1, 1, 1.0 )\ny = base.dists.erlang.quantile( -0.2, 1, 1.0 )\ny = base.dists.erlang.quantile( NaN, 1, 1.0 )\ny = base.dists.erlang.quantile( 0.0, NaN, 1.0 )\ny = base.dists.erlang.quantile( 0.0, 1, NaN )\n\n// Non-integer shape parameter:\ny = base.dists.erlang.quantile( 0.5, 0.5, 1.0 )\n\n// Non-positive shape parameter:\ny = base.dists.erlang.quantile( 0.5, -1, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.erlang.quantile( 0.5, 1, -1.0 )\n","base.dists.erlang.skewness":"var v = base.dists.erlang.skewness( 1, 1.0 )\nv = base.dists.erlang.skewness( 4, 12.0 )\nv = base.dists.erlang.skewness( 8, 2.0 )\n","base.dists.erlang.stdev":"var v = base.dists.erlang.stdev( 1, 1.0 )\nv = base.dists.erlang.stdev( 4, 12.0 )\nv = base.dists.erlang.stdev( 8, 2.0 )\n","base.dists.erlang.variance":"var v = base.dists.erlang.variance( 1, 1.0 )\nv = base.dists.erlang.variance( 4, 12.0 )\nv = base.dists.erlang.variance( 8, 2.0 )\n","base.dists.exponential.cdf":"var y = base.dists.exponential.cdf( 2.0, 0.1 )\ny = base.dists.exponential.cdf( 1.0, 2.0 )\ny = base.dists.exponential.cdf( -1.0, 4.0 )\ny = base.dists.exponential.cdf( NaN, 1.0 )\ny = base.dists.exponential.cdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.cdf( 2.0, -1.0 )\n","base.dists.exponential.entropy":"var v = base.dists.exponential.entropy( 11.0 )\nv = base.dists.exponential.entropy( 4.5 )\n","base.dists.exponential.Exponential":"var exponential = base.dists.exponential.Exponential( 6.0 );\nexponential.lambda\nexponential.entropy\nexponential.kurtosis\nexponential.mean\nexponential.median\nexponential.mode\nexponential.skewness\nexponential.stdev\nexponential.variance\nexponential.cdf( 1.0 )\nexponential.logcdf( 1.0 )\nexponential.logpdf( 1.5 )\nexponential.mgf( -0.5 )\nexponential.pdf( 1.5 )\nexponential.quantile( 0.5 )\n","base.dists.exponential.kurtosis":"var v = base.dists.exponential.kurtosis( 11.0 )\nv = base.dists.exponential.kurtosis( 4.5 )\n","base.dists.exponential.logcdf":"var y = base.dists.exponential.logcdf( 2.0, 0.1 )\ny = base.dists.exponential.logcdf( 1.0, 2.0 )\ny = base.dists.exponential.logcdf( -1.0, 4.0 )\ny = base.dists.exponential.logcdf( NaN, 1.0 )\ny = base.dists.exponential.logcdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.logcdf( 2.0, -1.0 )\n","base.dists.exponential.logpdf":"var y = base.dists.exponential.logpdf( 0.3, 4.0 )\ny = base.dists.exponential.logpdf( 2.0, 0.7 )\ny = base.dists.exponential.logpdf( -1.0, 0.5 )\ny = base.dists.exponential.logpdf( 0, NaN )\ny = base.dists.exponential.logpdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.logpdf( 2.0, -1.0 )\n","base.dists.exponential.mean":"var v = base.dists.exponential.mean( 11.0 )\nv = base.dists.exponential.mean( 4.5 )\n","base.dists.exponential.median":"var v = base.dists.exponential.median( 11.0 )\nv = base.dists.exponential.median( 4.5 )\n","base.dists.exponential.mode":"var v = base.dists.exponential.mode( 11.0 )\nv = base.dists.exponential.mode( 4.5 )\n","base.dists.exponential.pdf":"var y = base.dists.exponential.pdf( 0.3, 4.0 )\ny = base.dists.exponential.pdf( 2.0, 0.7 )\ny = base.dists.exponential.pdf( -1.0, 0.5 )\ny = base.dists.exponential.pdf( 0, NaN )\ny = base.dists.exponential.pdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.pdf( 2.0, -1.0 )\n","base.dists.exponential.quantile":"var y = base.dists.exponential.quantile( 0.8, 1.0 )\ny = base.dists.exponential.quantile( 0.5, 4.0 )\ny = base.dists.exponential.quantile( 0.5, 0.1 )\ny = base.dists.exponential.quantile( -0.2, 0.1 )\ny = base.dists.exponential.quantile( NaN, 1.0 )\ny = base.dists.exponential.quantile( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.quantile( 0.5, -1.0 )\n","base.dists.exponential.skewness":"var v = base.dists.exponential.skewness( 11.0 )\nv = base.dists.exponential.skewness( 4.5 )\n","base.dists.exponential.stdev":"var v = base.dists.exponential.stdev( 9.0 )\nv = base.dists.exponential.stdev( 1.0 )\n","base.dists.exponential.variance":"var v = base.dists.exponential.variance( 9.0 )\nv = base.dists.exponential.variance( 1.0 )\n","base.dists.f.cdf":"var y = base.dists.f.cdf( 2.0, 1.0, 1.0 )\nvar y = base.dists.f.cdf( 2.0, 8.0, 4.0 )\nvar y = base.dists.f.cdf( -1.0, 2.0, 2.0 )\nvar y = base.dists.f.cdf( PINF, 4.0, 2.0 )\nvar y = base.dists.f.cdf( NINF, 4.0, 2.0 )\nvar y = base.dists.f.cdf( NaN, 1.0, 1.0 )\nvar y = base.dists.f.cdf( 0.0, NaN, 1.0 )\nvar y = base.dists.f.cdf( 0.0, 1.0, NaN )\nvar y = base.dists.f.cdf( 2.0, 1.0, -1.0 )\nvar y = base.dists.f.cdf( 2.0, -1.0, 1.0 )\n","base.dists.f.entropy":"var v = base.dists.f.entropy( 3.0, 7.0 )\nv = base.dists.f.entropy( 4.0, 12.0 )\nv = base.dists.f.entropy( 8.0, 2.0 )\n","base.dists.f.F":"var f = base.dists.f.F( 6.0, 9.0 );\nf.d1\nf.d2\nf.entropy\nf.kurtosis\nf.mean\nf.mode\nf.skewness\nf.stdev\nf.variance\nf.cdf( 3.0 )\nf.pdf( 2.5 )\nf.quantile( 0.8 )\n","base.dists.f.kurtosis":"var v = base.dists.f.kurtosis( 3.0, 9.0 )\nv = base.dists.f.kurtosis( 4.0, 12.0 )\nv = base.dists.f.kurtosis( 8.0, 9.0 )\n","base.dists.f.mean":"var v = base.dists.f.mean( 3.0, 5.0 )\nv = base.dists.f.mean( 4.0, 12.0 )\nv = base.dists.f.mean( 8.0, 4.0 )\n","base.dists.f.mode":"var v = base.dists.f.mode( 3.0, 5.0 )\nv = base.dists.f.mode( 4.0, 12.0 )\nv = base.dists.f.mode( 8.0, 4.0 )\n","base.dists.f.pdf":"var y = base.dists.f.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.f.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.f.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.f.pdf( NaN, 1.0, 1.0 )\ny = base.dists.f.pdf( 0.0, NaN, 1.0 )\ny = base.dists.f.pdf( 0.0, 1.0, NaN )\ny = base.dists.f.pdf( 2.0, 1.0, -1.0 )\ny = base.dists.f.pdf( 2.0, -1.0, 1.0 )\n","base.dists.f.quantile":"var y = base.dists.f.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.f.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.f.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.f.quantile( NaN, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, NaN, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, NaN )\ny = base.dists.f.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, -1.0 )\n","base.dists.f.skewness":"var v = base.dists.f.skewness( 3.0, 7.0 )\nv = base.dists.f.skewness( 4.0, 12.0 )\nv = base.dists.f.skewness( 8.0, 7.0 )\n","base.dists.f.stdev":"var v = base.dists.f.stdev( 3.0, 5.0 )\nv = base.dists.f.stdev( 4.0, 12.0 )\nv = base.dists.f.stdev( 8.0, 5.0 )\n","base.dists.f.variance":"var v = base.dists.f.variance( 3.0, 5.0 )\nv = base.dists.f.variance( 4.0, 12.0 )\nv = base.dists.f.variance( 8.0, 5.0 )\n","base.dists.frechet.cdf":"var y = base.dists.frechet.cdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.cdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.cdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.cdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.cdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, -1.0, 0.0 )\n","base.dists.frechet.entropy":"var y = base.dists.frechet.entropy( 1.0, 1.0, 1.0 )\ny = base.dists.frechet.entropy( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.entropy( NaN, 1.0, 0.0 )\ny = base.dists.frechet.entropy( 1.0, NaN, 0.0 )\ny = base.dists.frechet.entropy( 1.0, 1.0, NaN )\n","base.dists.frechet.Frechet":"var frechet = base.dists.frechet.Frechet( 1.0, 1.0, 0.0 );\nfrechet.alpha\nfrechet.s\nfrechet.m\nfrechet.entropy\nfrechet.kurtosis\nfrechet.mean\nfrechet.median\nfrechet.mode\nfrechet.skewness\nfrechet.stdev\nfrechet.variance\nfrechet.cdf( 0.8 )\nfrechet.logcdf( 0.8 )\nfrechet.logpdf( 0.8 )\nfrechet.pdf( 0.8 )\nfrechet.quantile( 0.8 )\n","base.dists.frechet.kurtosis":"var y = base.dists.frechet.kurtosis( 5.0, 2.0, 1.0 )\nvar y = base.dists.frechet.kurtosis( 5.0, 10.0, -3.0 )\ny = base.dists.frechet.kurtosis( 3.5, 2.0, 1.0 )\ny = base.dists.frechet.kurtosis( NaN, 1.0, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, NaN, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, 1.0, NaN )\n","base.dists.frechet.logcdf":"var y = base.dists.frechet.logcdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.logcdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.logcdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.logcdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.logcdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, -1.0, 0.0 )\n","base.dists.frechet.logpdf":"var y = base.dists.frechet.logpdf( 10.0, 1.0, 3.0, 5.0 )\ny = base.dists.frechet.logpdf( -2.0, 1.0, 3.0, -3.0 )\ny = base.dists.frechet.logpdf( 0.0, 2.0, 1.0, -1.0 )\ny = base.dists.frechet.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.logpdf( 0.0, 0.0, -1.0 )\n","base.dists.frechet.mean":"var y = base.dists.frechet.mean( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.mean( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mean( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mean( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mean( 1.0, 1.0, NaN )\n","base.dists.frechet.median":"var y = base.dists.frechet.median( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.median( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.median( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.median( NaN, 1.0, 0.0 )\ny = base.dists.frechet.median( 1.0, NaN, 0.0 )\ny = base.dists.frechet.median( 1.0, 1.0, NaN )\n","base.dists.frechet.mode":"var y = base.dists.frechet.mode( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.mode( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.mode( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mode( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mode( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mode( 1.0, 1.0, NaN )\n","base.dists.frechet.pdf":"var y = base.dists.frechet.pdf( 10.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( -2.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.frechet.pdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.pdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.pdf( 0.0, 0.0, -1.0 )\n","base.dists.frechet.quantile":"var y = base.dists.frechet.quantile( 0.3, 10.0, 2.0, 3.0 )\ny = base.dists.frechet.quantile( 0.2, 3.0, 3.0, 3.0 )\ny = base.dists.frechet.quantile( 0.9, 1.0, 1.0, -3.0 )\ny = base.dists.frechet.quantile( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, NaN, 1.0, 0.0)\ny = base.dists.frechet.quantile( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.quantile( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, -1.0, 0.0 )\n","base.dists.frechet.skewness":"var y = base.dists.frechet.skewness( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.skewness( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.skewness( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.skewness( NaN, 1.0, 0.0 )\ny = base.dists.frechet.skewness( 1.0, NaN, 0.0 )\ny = base.dists.frechet.skewness( 1.0, 1.0, NaN )\n","base.dists.frechet.stdev":"var y = base.dists.frechet.stdev( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.stdev( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.stdev( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.stdev( NaN, 1.0, 0.0 )\ny = base.dists.frechet.stdev( 1.0, NaN, 0.0 )\ny = base.dists.frechet.stdev( 1.0, 1.0, NaN )\n","base.dists.frechet.variance":"var y = base.dists.frechet.variance( 4.0, 2.0, 1.0 )\nvar y = base.dists.frechet.variance( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.variance( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.variance( NaN, 1.0, 0.0 )\ny = base.dists.frechet.variance( 1.0, NaN, 0.0 )\ny = base.dists.frechet.variance( 1.0, 1.0, NaN )\n","base.dists.gamma.cdf":"var y = base.dists.gamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.gamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.gamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.gamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0` when `α = 0.0`:\ny = base.dists.gamma.cdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( -2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, 2.0 )\n","base.dists.gamma.entropy":"var v = base.dists.gamma.entropy( 1.0, 1.0 )\nv = base.dists.gamma.entropy( 4.0, 12.0 )\nv = base.dists.gamma.entropy( 8.0, 2.0 )\n","base.dists.gamma.Gamma":"var gamma = base.dists.gamma.Gamma( 6.0, 5.0 );\ngamma.alpha\ngamma.beta\ngamma.entropy\ngamma.kurtosis\ngamma.mean\ngamma.mode\ngamma.skewness\ngamma.stdev\ngamma.variance\ngamma.cdf( 0.8 )\ngamma.logpdf( 1.0 )\ngamma.mgf( -0.5 )\ngamma.pdf( 1.0 )\ngamma.quantile( 0.8 )\n","base.dists.gamma.kurtosis":"var v = base.dists.gamma.kurtosis( 1.0, 1.0 )\nv = base.dists.gamma.kurtosis( 4.0, 12.0 )\nv = base.dists.gamma.kurtosis( 8.0, 2.0 )\n","base.dists.gamma.logpdf":"var y = base.dists.gamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.logpdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.logpdf( 0.0, 0.0, 2.0 )\n","base.dists.gamma.mean":"var v = base.dists.gamma.mean( 1.0, 1.0 )\nv = base.dists.gamma.mean( 4.0, 12.0 )\nv = base.dists.gamma.mean( 8.0, 2.0 )\n","base.dists.gamma.mgf":"var y = base.dists.gamma.mgf( 0.5, 0.5, 1.0 )\ny = base.dists.gamma.mgf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.mgf( NaN, 1.0, 1.0 )\ny = base.dists.gamma.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.mgf( 0.0, 1.0, NaN )\ny = base.dists.gamma.mgf( 2.0, 4.0, 1.0 )\ny = base.dists.gamma.mgf( 2.0, -0.5, 1.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, 0.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, -1.0 )\n","base.dists.gamma.mode":"var v = base.dists.gamma.mode( 1.0, 1.0 )\nv = base.dists.gamma.mode( 4.0, 12.0 )\nv = base.dists.gamma.mode( 8.0, 2.0 )\n","base.dists.gamma.pdf":"var y = base.dists.gamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.pdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.pdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.pdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.pdf( 0.0, 0.0, 2.0 )\n","base.dists.gamma.quantile":"var y = base.dists.gamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.gamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.gamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.gamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.gamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.gamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.quantile( 0.5, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.quantile( 0.3, 0.0, 2.0 )\ny = base.dists.gamma.quantile( 0.9, 0.0, 2.0 )\n","base.dists.gamma.skewness":"var v = base.dists.gamma.skewness( 1.0, 1.0 )\nv = base.dists.gamma.skewness( 4.0, 12.0 )\nv = base.dists.gamma.skewness( 8.0, 2.0 )\n","base.dists.gamma.stdev":"var v = base.dists.gamma.stdev( 1.0, 1.0 )\nv = base.dists.gamma.stdev( 4.0, 12.0 )\nv = base.dists.gamma.stdev( 8.0, 2.0 )\n","base.dists.gamma.variance":"var v = base.dists.gamma.variance( 1.0, 1.0 )\nv = base.dists.gamma.variance( 4.0, 12.0 )\nv = base.dists.gamma.variance( 8.0, 2.0 )\n","base.dists.geometric.cdf":"var y = base.dists.geometric.cdf( 2.0, 0.5 )\ny = base.dists.geometric.cdf( 2.0, 0.1 )\ny = base.dists.geometric.cdf( -1.0, 4.0 )\ny = base.dists.geometric.cdf( NaN, 0.5 )\ny = base.dists.geometric.cdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.cdf( 2.0, 1.4 )\n","base.dists.geometric.entropy":"var v = base.dists.geometric.entropy( 0.1 )\nv = base.dists.geometric.entropy( 0.5 )\n","base.dists.geometric.Geometric":"var geometric = base.dists.geometric.Geometric( 0.6 );\ngeometric.p\ngeometric.entropy\ngeometric.kurtosis\ngeometric.mean\ngeometric.median\ngeometric.mode\ngeometric.skewness\ngeometric.stdev\ngeometric.variance\ngeometric.cdf( 3.0 )\ngeometric.logcdf( 3.0 )\ngeometric.logpmf( 4.0 )\ngeometric.mgf( 0.5 )\ngeometric.pmf( 2.0 )\ngeometric.quantile( 0.7 )\n","base.dists.geometric.kurtosis":"var v = base.dists.geometric.kurtosis( 0.1 )\nv = base.dists.geometric.kurtosis( 0.5 )\n","base.dists.geometric.logcdf":"var y = base.dists.geometric.logcdf( 2.0, 0.5 )\ny = base.dists.geometric.logcdf( 2.0, 0.1 )\ny = base.dists.geometric.logcdf( -1.0, 4.0 )\ny = base.dists.geometric.logcdf( NaN, 0.5 )\ny = base.dists.geometric.logcdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.logcdf( 2.0, 1.4 )\n","base.dists.geometric.logpmf":"var y = base.dists.geometric.logpmf( 4.0, 0.3 )\ny = base.dists.geometric.logpmf( 2.0, 0.7 )\ny = base.dists.geometric.logpmf( -1.0, 0.5 )\ny = base.dists.geometric.logpmf( 0.0, NaN )\ny = base.dists.geometric.logpmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.logpmf( 2.0, 1.5 )\n","base.dists.geometric.mean":"var v = base.dists.geometric.mean( 0.1 )\nv = base.dists.geometric.mean( 0.5 )\n","base.dists.geometric.median":"var v = base.dists.geometric.median( 0.1 )\nv = base.dists.geometric.median( 0.5 )\n","base.dists.geometric.mgf":"var y = base.dists.geometric.mgf( 0.2, 0.5 )\ny = base.dists.geometric.mgf( 0.4, 0.5 )\n\n// Case: t >= -ln(1-p)\ny = base.dists.geometric.mgf( 0.8, 0.5 )\ny = base.dists.geometric.mgf( NaN, 0.0 )\ny = base.dists.geometric.mgf( 0.0, NaN )\ny = base.dists.geometric.mgf( -2.0, -1.0 )\ny = base.dists.geometric.mgf( 0.2, 2.0 )\n","base.dists.geometric.mode":"var v = base.dists.geometric.mode( 0.1 )\nv = base.dists.geometric.mode( 0.5 )\n","base.dists.geometric.pmf":"var y = base.dists.geometric.pmf( 4.0, 0.3 )\ny = base.dists.geometric.pmf( 2.0, 0.7 )\ny = base.dists.geometric.pmf( -1.0, 0.5 )\ny = base.dists.geometric.pmf( 0.0, NaN )\ny = base.dists.geometric.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.pmf( 2.0, 1.5 )\n","base.dists.geometric.quantile":"var y = base.dists.geometric.quantile( 0.8, 0.4 )\ny = base.dists.geometric.quantile( 0.5, 0.4 )\ny = base.dists.geometric.quantile( 0.9, 0.1 )\ny = base.dists.geometric.quantile( -0.2, 0.1 )\ny = base.dists.geometric.quantile( NaN, 0.8 )\ny = base.dists.geometric.quantile( 0.4, NaN )\ny = base.dists.geometric.quantile( 0.5, -1.0 )\ny = base.dists.geometric.quantile( 0.5, 1.5 )\n","base.dists.geometric.skewness":"var v = base.dists.geometric.skewness( 0.1 )\nv = base.dists.geometric.skewness( 0.5 )\n","base.dists.geometric.stdev":"var v = base.dists.geometric.stdev( 0.1 )\nv = base.dists.geometric.stdev( 0.5 )\n","base.dists.geometric.variance":"var v = base.dists.geometric.variance( 0.1 )\nv = base.dists.geometric.variance( 0.5 )\n","base.dists.gumbel.cdf":"var y = base.dists.gumbel.cdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.cdf( 0.0, 0.0, -1.0 )\n","base.dists.gumbel.entropy":"var y = base.dists.gumbel.entropy( 0.0, 1.0 )\ny = base.dists.gumbel.entropy( 4.0, 2.0 )\ny = base.dists.gumbel.entropy( NaN, 1.0 )\ny = base.dists.gumbel.entropy( 0.0, NaN )\ny = base.dists.gumbel.entropy( 0.0, 0.0 )\n","base.dists.gumbel.Gumbel":"var gumbel = base.dists.gumbel.Gumbel( -2.0, 3.0 );\ngumbel.mu\ngumbel.beta\ngumbel.entropy\ngumbel.kurtosis\ngumbel.mean\ngumbel.median\ngumbel.mode\ngumbel.skewness\ngumbel.stdev\ngumbel.variance\ngumbel.cdf( 0.8 )\ngumbel.logcdf( 0.8 )\ngumbel.logpdf( 1.0 )\ngumbel.mgf( 0.2 )\ngumbel.pdf( 1.0 )\ngumbel.quantile( 0.8 )\n","base.dists.gumbel.kurtosis":"var y = base.dists.gumbel.kurtosis( 0.0, 1.0 )\ny = base.dists.gumbel.kurtosis( 4.0, 2.0 )\ny = base.dists.gumbel.kurtosis( NaN, 1.0 )\ny = base.dists.gumbel.kurtosis( 0.0, NaN )\ny = base.dists.gumbel.kurtosis( 0.0, 0.0 )\n","base.dists.gumbel.logcdf":"var y = base.dists.gumbel.logcdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logcdf( 0.0, 0.0, -1.0 )\n","base.dists.gumbel.logpdf":"var y = base.dists.gumbel.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logpdf( 2.0, 0.0, -1.0 )\n","base.dists.gumbel.mean":"var y = base.dists.gumbel.mean( 0.0, 1.0 )\ny = base.dists.gumbel.mean( 4.0, 2.0 )\ny = base.dists.gumbel.mean( NaN, 1.0 )\ny = base.dists.gumbel.mean( 0.0, NaN )\ny = base.dists.gumbel.mean( 0.0, 0.0 )\n","base.dists.gumbel.median":"var y = base.dists.gumbel.median( 0.0, 1.0 )\ny = base.dists.gumbel.median( 4.0, 2.0 )\ny = base.dists.gumbel.median( NaN, 1.0 )\ny = base.dists.gumbel.median( 0.0, NaN )\ny = base.dists.gumbel.median( 0.0, 0.0 )\n","base.dists.gumbel.mgf":"var y = base.dists.gumbel.mgf( -1.0, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.1, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, NaN )\n\n// Case: `t >= 1/beta`\ny = base.dists.gumbel.mgf( 0.8, 0.0, 2.0 )\n\n// Non-positive scale parameter:\ny = base.dists.gumbel.mgf( 0.0, 0.0, -1.0 )\n","base.dists.gumbel.mode":"var y = base.dists.gumbel.mode( 0.0, 1.0 )\ny = base.dists.gumbel.mode( 4.0, 2.0 )\ny = base.dists.gumbel.mode( NaN, 1.0 )\ny = base.dists.gumbel.mode( 0.0, NaN )\ny = base.dists.gumbel.mode( 0.0, 0.0 )\n","base.dists.gumbel.pdf":"var y = base.dists.gumbel.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.pdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.pdf( 2.0, 0.0, -1.0 )\n","base.dists.gumbel.quantile":"var y = base.dists.gumbel.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 4.0 )\ny = base.dists.gumbel.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.quantile( 0.5, 0.0, -1.0 )\n","base.dists.gumbel.skewness":"var y = base.dists.gumbel.skewness( 0.0, 1.0 )\ny = base.dists.gumbel.skewness( 4.0, 2.0 )\ny = base.dists.gumbel.skewness( NaN, 1.0 )\ny = base.dists.gumbel.skewness( 0.0, NaN )\ny = base.dists.gumbel.skewness( 0.0, 0.0 )\n","base.dists.gumbel.stdev":"var y = base.dists.gumbel.stdev( 0.0, 1.0 )\ny = base.dists.gumbel.stdev( 4.0, 2.0 )\ny = base.dists.gumbel.stdev( NaN, 1.0 )\ny = base.dists.gumbel.stdev( 0.0, NaN )\ny = base.dists.gumbel.stdev( 0.0, 0.0 )\n","base.dists.gumbel.variance":"var y = base.dists.gumbel.variance( 0.0, 1.0 )\ny = base.dists.gumbel.variance( 4.0, 2.0 )\ny = base.dists.gumbel.variance( NaN, 1.0 )\ny = base.dists.gumbel.variance( 0.0, NaN )\ny = base.dists.gumbel.variance( 0.0, 0.0 )\n","base.dists.hypergeometric.cdf":"var y = base.dists.hypergeometric.cdf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 0, 8, 4, 2)\ny = base.dists.hypergeometric.cdf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.cdf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 1.5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 3, 9 )\n","base.dists.hypergeometric.Hypergeometric":"var hypergeometric = base.dists.hypergeometric.Hypergeometric( 100, 70, 20 );\nhypergeometric.N\nhypergeometric.K\nhypergeometric.n\nhypergeometric.kurtosis\nhypergeometric.mean\nhypergeometric.mode\nhypergeometric.skewness\nhypergeometric.stdev\nhypergeometric.variance\nhypergeometric.cdf( 2.9 )\nhypergeometric.logpmf( 10 )\nhypergeometric.pmf( 10 )\nhypergeometric.quantile( 0.8 )\n","base.dists.hypergeometric.kurtosis":"var v = base.dists.hypergeometric.kurtosis( 16, 11, 4 )\nv = base.dists.hypergeometric.kurtosis( 4, 2, 2 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 12 )\nv = base.dists.hypergeometric.kurtosis( 10.3, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5.5, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 4.5 )\nv = base.dists.hypergeometric.kurtosis( NaN, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, NaN, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, 10, NaN )\n","base.dists.hypergeometric.logpmf":"var y = base.dists.hypergeometric.logpmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.logpmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 3, 9 )\n","base.dists.hypergeometric.mean":"var v = base.dists.hypergeometric.mean( 16, 11, 4 )\nv = base.dists.hypergeometric.mean( 2, 1, 1 )\nv = base.dists.hypergeometric.mean( 10, 5, 12 )\nv = base.dists.hypergeometric.mean( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mean( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mean( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mean( NaN, 10, 4 )\nv = base.dists.hypergeometric.mean( 20, NaN, 4 )\nv = base.dists.hypergeometric.mean( 20, 10, NaN )\n","base.dists.hypergeometric.mode":"var v = base.dists.hypergeometric.mode( 16, 11, 4 )\nv = base.dists.hypergeometric.mode( 2, 1, 1 )\nv = base.dists.hypergeometric.mode( 10, 5, 12 )\nv = base.dists.hypergeometric.mode( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mode( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mode( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mode( NaN, 10, 4 )\nv = base.dists.hypergeometric.mode( 20, NaN, 4 )\nv = base.dists.hypergeometric.mode( 20, 10, NaN )\n","base.dists.hypergeometric.pmf":"var y = base.dists.hypergeometric.pmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.pmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 3, 9 )\n","base.dists.hypergeometric.quantile":"var y = base.dists.hypergeometric.quantile( 0.4, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.8, 60, 40, 20 )\ny = base.dists.hypergeometric.quantile( 0.5, 100, 10, 10 )\ny = base.dists.hypergeometric.quantile( 0.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( 1.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( NaN, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, NaN, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, NaN, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, 20, NaN )\n","base.dists.hypergeometric.skewness":"var v = base.dists.hypergeometric.skewness( 16, 11, 4 )\nv = base.dists.hypergeometric.skewness( 4, 2, 2 )\nv = base.dists.hypergeometric.skewness( 10, 5, 12 )\nv = base.dists.hypergeometric.skewness( 10.3, 10, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5.5, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5, 4.5 )\nv = base.dists.hypergeometric.skewness( NaN, 10, 4 )\nv = base.dists.hypergeometric.skewness( 20, NaN, 4 )\nv = base.dists.hypergeometric.skewness( 20, 10, NaN )\n","base.dists.hypergeometric.stdev":"var v = base.dists.hypergeometric.stdev( 16, 11, 4 )\nv = base.dists.hypergeometric.stdev( 2, 1, 1 )\nv = base.dists.hypergeometric.stdev( 10, 5, 12 )\nv = base.dists.hypergeometric.stdev( 10.3, 10, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5.5, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5, 4.5 )\nv = base.dists.hypergeometric.stdev( NaN, 10, 4 )\nv = base.dists.hypergeometric.stdev( 20, NaN, 4 )\nv = base.dists.hypergeometric.stdev( 20, 10, NaN )\n","base.dists.hypergeometric.variance":"var v = base.dists.hypergeometric.variance( 16, 11, 4 )\nv = base.dists.hypergeometric.variance( 2, 1, 1 )\nv = base.dists.hypergeometric.variance( 10, 5, 12 )\nv = base.dists.hypergeometric.variance( 10.3, 10, 4 )\nv = base.dists.hypergeometric.variance( 10, 5.5, 4 )\nv = base.dists.hypergeometric.variance( 10, 5, 4.5 )\nv = base.dists.hypergeometric.variance( NaN, 10, 4 )\nv = base.dists.hypergeometric.variance( 20, NaN, 4 )\nv = base.dists.hypergeometric.variance( 20, 10, NaN )\n","base.dists.invgamma.cdf":"var y = base.dists.invgamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.invgamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.invgamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.invgamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 1.0, -1.0 )\n","base.dists.invgamma.entropy":"var v = base.dists.invgamma.entropy( 1.0, 1.0 )\nv = base.dists.invgamma.entropy( 4.0, 12.0 )\nv = base.dists.invgamma.entropy( 8.0, 2.0 )\n","base.dists.invgamma.InvGamma":"var invgamma = base.dists.invgamma.InvGamma( 6.0, 5.0 );\ninvgamma.alpha\ninvgamma.beta\ninvgamma.entropy\ninvgamma.kurtosis\ninvgamma.mean\ninvgamma.mode\ninvgamma.skewness\ninvgamma.stdev\ninvgamma.variance\ninvgamma.cdf( 0.8 )\ninvgamma.pdf( 1.0 )\ninvgamma.logpdf( 1.0 )\ninvgamma.quantile( 0.8 )\n","base.dists.invgamma.kurtosis":"var v = base.dists.invgamma.kurtosis( 7.0, 5.0 )\nv = base.dists.invgamma.kurtosis( 6.0, 12.0 )\nv = base.dists.invgamma.kurtosis( 8.0, 2.0 )\n","base.dists.invgamma.logpdf":"var y = base.dists.invgamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.logpdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.logpdf( 2.0, 1.0, -1.0 )\n","base.dists.invgamma.mean":"var v = base.dists.invgamma.mean( 4.0, 12.0 )\nv = base.dists.invgamma.mean( 8.0, 2.0 )\n","base.dists.invgamma.mode":"var v = base.dists.invgamma.mode( 1.0, 1.0 )\nv = base.dists.invgamma.mode( 4.0, 12.0 )\nv = base.dists.invgamma.mode( 8.0, 2.0 )\n","base.dists.invgamma.pdf":"var y = base.dists.invgamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.pdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.pdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.pdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.pdf( 2.0, 1.0, -1.0 )\n","base.dists.invgamma.quantile":"var y = base.dists.invgamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.invgamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.invgamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.invgamma.quantile( 0.5, 1.0, -1.0 )\n","base.dists.invgamma.skewness":"var v = base.dists.invgamma.skewness( 4.0, 12.0 )\nv = base.dists.invgamma.skewness( 8.0, 2.0 )\n","base.dists.invgamma.stdev":"var v = base.dists.invgamma.stdev( 5.0, 7.0 )\nv = base.dists.invgamma.stdev( 4.0, 12.0 )\nv = base.dists.invgamma.stdev( 8.0, 2.0 )\n","base.dists.invgamma.variance":"var v = base.dists.invgamma.variance( 5.0, 7.0 )\nv = base.dists.invgamma.variance( 4.0, 12.0 )\nv = base.dists.invgamma.variance( 8.0, 2.0 )\n","base.dists.kumaraswamy.cdf":"var y = base.dists.kumaraswamy.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.cdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, 1.0, NaN )\n","base.dists.kumaraswamy.Kumaraswamy":"var kumaraswamy = base.dists.kumaraswamy.Kumaraswamy( 6.0, 5.0 );\nkumaraswamy.a\nkumaraswamy.b\nkumaraswamy.kurtosis\nkumaraswamy.mean\nkumaraswamy.mode\nkumaraswamy.skewness\nkumaraswamy.stdev\nkumaraswamy.variance\nkumaraswamy.cdf( 0.8 )\nkumaraswamy.pdf( 1.0 )\nkumaraswamy.quantile( 0.8 )\n","base.dists.kumaraswamy.kurtosis":"var v = base.dists.kumaraswamy.kurtosis( 1.0, 1.0 )\nv = base.dists.kumaraswamy.kurtosis( 4.0, 12.0 )\nv = base.dists.kumaraswamy.kurtosis( 16.0, 8.0 )\n","base.dists.kumaraswamy.logcdf":"var y = base.dists.kumaraswamy.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, 1.0, NaN )\n","base.dists.kumaraswamy.logpdf":"var y = base.dists.kumaraswamy.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logpdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, 1.0, NaN )\n","base.dists.kumaraswamy.mean":"var v = base.dists.kumaraswamy.mean( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mean( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mean( 16.0, 8.0 )\n","base.dists.kumaraswamy.median":"var v = base.dists.kumaraswamy.median( 1.0, 1.0 )\nv = base.dists.kumaraswamy.median( 4.0, 12.0 )\nv = base.dists.kumaraswamy.median( 16.0, 8.0 )\n","base.dists.kumaraswamy.mode":"var v = base.dists.kumaraswamy.mode( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mode( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mode( 16.0, 8.0 )\n","base.dists.kumaraswamy.pdf":"var y = base.dists.kumaraswamy.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.pdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, 1.0, NaN )\n","base.dists.kumaraswamy.quantile":"var y = base.dists.kumaraswamy.quantile( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.quantile( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.quantile( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, 1.0, NaN )\n","base.dists.kumaraswamy.skewness":"var v = base.dists.kumaraswamy.skewness( 1.0, 1.0 )\nv = base.dists.kumaraswamy.skewness( 4.0, 12.0 )\nv = base.dists.kumaraswamy.skewness( 16.0, 8.0 )\n","base.dists.kumaraswamy.stdev":"var v = base.dists.kumaraswamy.stdev( 1.0, 1.0 )\nv = base.dists.kumaraswamy.stdev( 4.0, 12.0 )\nv = base.dists.kumaraswamy.stdev( 16.0, 8.0 )\n","base.dists.kumaraswamy.variance":"var v = base.dists.kumaraswamy.variance( 1.0, 1.0 )\nv = base.dists.kumaraswamy.variance( 4.0, 12.0 )\nv = base.dists.kumaraswamy.variance( 16.0, 8.0 )\n","base.dists.laplace.cdf":"var y = base.dists.laplace.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.cdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 2, NaN, 1.0 )\ny = base.dists.laplace.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.cdf( 2.0, 0.0, -1.0 )\n","base.dists.laplace.entropy":"var y = base.dists.laplace.entropy( 0.0, 1.0 )\ny = base.dists.laplace.entropy( 4.0, 2.0 )\ny = base.dists.laplace.entropy( NaN, 1.0 )\ny = base.dists.laplace.entropy( 0.0, NaN )\ny = base.dists.laplace.entropy( 0.0, 0.0 )\n","base.dists.laplace.kurtosis":"var y = base.dists.laplace.kurtosis( 0.0, 1.0 )\ny = base.dists.laplace.kurtosis( 4.0, 2.0 )\ny = base.dists.laplace.kurtosis( NaN, 1.0 )\ny = base.dists.laplace.kurtosis( 0.0, NaN )\ny = base.dists.laplace.kurtosis( 0.0, 0.0 )\n","base.dists.laplace.Laplace":"var laplace = base.dists.laplace.Laplace( -2.0, 3.0 );\nlaplace.mu\nlaplace.b\nlaplace.entropy\nlaplace.kurtosis\nlaplace.mean\nlaplace.median\nlaplace.mode\nlaplace.skewness\nlaplace.stdev\nlaplace.variance\nlaplace.cdf( 0.8 )\nlaplace.logcdf( 0.8 )\nlaplace.logpdf( 1.0 )\nlaplace.mgf( 0.2 )\nlaplace.pdf( 2.0 )\nlaplace.quantile( 0.9 )\n","base.dists.laplace.logcdf":"var y = base.dists.laplace.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 2, NaN, 1.0 )\ny = base.dists.laplace.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logcdf( 2.0, 0.0, -1.0 )\n","base.dists.laplace.logpdf":"var y = base.dists.laplace.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logpdf( 2.0, 0.0, -1.0 )\n","base.dists.laplace.mean":"var y = base.dists.laplace.mean( 0.0, 1.0 )\ny = base.dists.laplace.mean( 4.0, 2.0 )\ny = base.dists.laplace.mean( NaN, 1.0 )\ny = base.dists.laplace.mean( 0.0, NaN )\ny = base.dists.laplace.mean( 0.0, 0.0 )\n","base.dists.laplace.median":"var y = base.dists.laplace.median( 0.0, 1.0 )\ny = base.dists.laplace.median( 4.0, 2.0 )\ny = base.dists.laplace.median( NaN, 1.0 )\ny = base.dists.laplace.median( 0.0, NaN )\ny = base.dists.laplace.median( 0.0, 0.0 )\n","base.dists.laplace.mgf":"var y = base.dists.laplace.mgf( 0.5, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.laplace.mgf( -1.0, 4.0, 0.2 )\ny = base.dists.laplace.mgf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, NaN )\ny = base.dists.laplace.mgf( 1.0, 0.0, 2.0 )\ny = base.dists.laplace.mgf( -0.5, 0.0, 4.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, 0.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, -1.0 )\n","base.dists.laplace.mode":"var y = base.dists.laplace.mode( 0.0, 1.0 )\ny = base.dists.laplace.mode( 4.0, 2.0 )\ny = base.dists.laplace.mode( NaN, 1.0 )\ny = base.dists.laplace.mode( 0.0, NaN )\ny = base.dists.laplace.mode( 0.0, 0.0 )\n","base.dists.laplace.pdf":"var y = base.dists.laplace.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.pdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.pdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.pdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.pdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.pdf( 2.0, 0.0, -1.0 )\n","base.dists.laplace.quantile":"var y = base.dists.laplace.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.laplace.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.laplace.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.laplace.quantile( NaN, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.0, NaN, 1.0 )\ny = base.dists.laplace.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.quantile( 0.5, 0.0, -1.0 )\n","base.dists.laplace.skewness":"var y = base.dists.laplace.skewness( 0.0, 1.0 )\ny = base.dists.laplace.skewness( 4.0, 2.0 )\ny = base.dists.laplace.skewness( NaN, 1.0 )\ny = base.dists.laplace.skewness( 0.0, NaN )\ny = base.dists.laplace.skewness( 0.0, 0.0 )\n","base.dists.laplace.stdev":"var y = base.dists.laplace.stdev( 0.0, 1.0 )\ny = base.dists.laplace.stdev( 4.0, 2.0 )\ny = base.dists.laplace.stdev( NaN, 1.0 )\ny = base.dists.laplace.stdev( 0.0, NaN )\ny = base.dists.laplace.stdev( 0.0, 0.0 )\n","base.dists.laplace.variance":"var y = base.dists.laplace.variance( 0.0, 1.0 )\ny = base.dists.laplace.variance( 4.0, 2.0 )\ny = base.dists.laplace.variance( NaN, 1.0 )\ny = base.dists.laplace.variance( 0.0, NaN )\ny = base.dists.laplace.variance( 0.0, 0.0 )\n","base.dists.levy.cdf":"var y = base.dists.levy.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.cdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.cdf( 2, NaN, 1.0 )\ny = base.dists.levy.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.cdf( 2.0, 0.0, -1.0 )\n","base.dists.levy.entropy":"var y = base.dists.levy.entropy( 0.0, 1.0 )\ny = base.dists.levy.entropy( 4.0, 2.0 )\ny = base.dists.levy.entropy( NaN, 1.0 )\ny = base.dists.levy.entropy( 0.0, NaN )\ny = base.dists.levy.entropy( 0.0, 0.0 )\n","base.dists.levy.Levy":"var levy = base.dists.levy.Levy( -2.0, 3.0 );\nlevy.mu\nlevy.c\nlevy.entropy\nlevy.mean\nlevy.median\nlevy.mode\nlevy.stdev\nlevy.variance\nlevy.cdf( 0.8 )\nlevy.logcdf( 0.8 )\nlevy.logpdf( 1.0 )\nlevy.pdf( 1.0 )\nlevy.quantile( 0.8 )\n","base.dists.levy.logcdf":"var y = base.dists.levy.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 2, NaN, 1.0 )\ny = base.dists.levy.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logcdf( 2.0, 0.0, -1.0 )\n","base.dists.levy.logpdf":"var y = base.dists.levy.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logpdf( 2.0, 0.0, -1.0 )\n","base.dists.levy.mean":"var y = base.dists.levy.mean( 0.0, 1.0 )\ny = base.dists.levy.mean( 4.0, 3.0 )\ny = base.dists.levy.mean( NaN, 1.0 )\ny = base.dists.levy.mean( 0.0, NaN )\ny = base.dists.levy.mean( 0.0, 0.0 )\n","base.dists.levy.median":"var y = base.dists.levy.median( 0.0, 1.0 )\ny = base.dists.levy.median( 4.0, 3.0 )\ny = base.dists.levy.median( NaN, 1.0 )\ny = base.dists.levy.median( 0.0, NaN )\ny = base.dists.levy.median( 0.0, 0.0 )\n","base.dists.levy.mode":"var y = base.dists.levy.mode( 0.0, 1.0 )\ny = base.dists.levy.mode( 4.0, 3.0 )\ny = base.dists.levy.mode( NaN, 1.0 )\ny = base.dists.levy.mode( 0.0, NaN )\ny = base.dists.levy.mode( 0.0, 0.0 )\n","base.dists.levy.pdf":"var y = base.dists.levy.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.pdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.pdf( 2.0, 0.0, -1.0 )\n","base.dists.levy.quantile":"var y = base.dists.levy.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.levy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.levy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.levy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.levy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.quantile( 0.5, 0.0, -1.0 )\n","base.dists.levy.stdev":"var y = base.dists.levy.stdev( 0.0, 1.0 )\ny = base.dists.levy.stdev( 4.0, 3.0 )\ny = base.dists.levy.stdev( NaN, 1.0 )\ny = base.dists.levy.stdev( 0.0, NaN )\ny = base.dists.levy.stdev( 0.0, 0.0 )\n","base.dists.levy.variance":"var y = base.dists.levy.variance( 0.0, 1.0 )\ny = base.dists.levy.variance( 4.0, 3.0 )\ny = base.dists.levy.variance( NaN, 1.0 )\ny = base.dists.levy.variance( 0.0, NaN )\ny = base.dists.levy.variance( 0.0, 0.0 )\n","base.dists.logistic.cdf":"var y = base.dists.logistic.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.cdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.cdf( 2.0, NaN, 1.0 )\ny = base.dists.logistic.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.logistic.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 10.0, 8.0, 0.0 )\n","base.dists.logistic.entropy":"var y = base.dists.logistic.entropy( 0.0, 1.0 )\ny = base.dists.logistic.entropy( 4.0, 2.0 )\ny = base.dists.logistic.entropy( NaN, 1.0 )\ny = base.dists.logistic.entropy( 0.0, NaN )\ny = base.dists.logistic.entropy( 0.0, 0.0 )\n","base.dists.logistic.kurtosis":"var y = base.dists.logistic.kurtosis( 0.0, 1.0 )\ny = base.dists.logistic.kurtosis( 4.0, 2.0 )\ny = base.dists.logistic.kurtosis( NaN, 1.0 )\ny = base.dists.logistic.kurtosis( 0.0, NaN )\ny = base.dists.logistic.kurtosis( 0.0, 0.0 )\n","base.dists.logistic.logcdf":"var y = base.dists.logistic.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.logcdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.logcdf( 2, NaN, 1.0 )\ny = base.dists.logistic.logcdf( NaN, 0.0, 1.0 )\n","base.dists.logistic.Logistic":"var logistic = base.dists.logistic.Logistic( -2.0, 3.0 );\nlogistic.mu\nlogistic.s\nlogistic.entropy\nlogistic.kurtosis\nlogistic.mean\nlogistic.median\nlogistic.mode\nlogistic.skewness\nlogistic.stdev\nlogistic.variance\nlogistic.cdf( 0.8 )\nlogistic.logcdf( 0.8 )\nlogistic.logpdf( 2.0 )\nlogistic.mgf( 0.2 )\nlogistic.pdf( 2.0 )\nlogistic.quantile( 0.9 )\n","base.dists.logistic.logpdf":"var y = base.dists.logistic.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.logistic.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.logpdf( 8.0, 8.0, 0.0 )\n","base.dists.logistic.mean":"var y = base.dists.logistic.mean( 0.0, 1.0 )\ny = base.dists.logistic.mean( 4.0, 2.0 )\ny = base.dists.logistic.mean( NaN, 1.0 )\ny = base.dists.logistic.mean( 0.0, NaN )\ny = base.dists.logistic.mean( 0.0, 0.0 )\n","base.dists.logistic.median":"var y = base.dists.logistic.median( 0.0, 1.0 )\ny = base.dists.logistic.median( 4.0, 2.0 )\ny = base.dists.logistic.median( NaN, 1.0 )\ny = base.dists.logistic.median( 0.0, NaN )\ny = base.dists.logistic.median( 0.0, 0.0 )\n","base.dists.logistic.mgf":"var y = base.dists.logistic.mgf( 0.9, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.1, 4.0, 4.0 )\ny = base.dists.logistic.mgf( -0.2, 4.0, 4.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, -1.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, 4.0 )\ny = base.dists.logistic.mgf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.mgf( 0.0, 0.0, NaN )\n","base.dists.logistic.mode":"var y = base.dists.logistic.mode( 0.0, 1.0 )\ny = base.dists.logistic.mode( 4.0, 2.0 )\ny = base.dists.logistic.mode( NaN, 1.0 )\ny = base.dists.logistic.mode( 0.0, NaN )\ny = base.dists.logistic.mode( 0.0, 0.0 )\n","base.dists.logistic.pdf":"var y = base.dists.logistic.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.pdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.pdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.logistic.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.pdf( 8.0, 8.0, 0.0 )\n","base.dists.logistic.quantile":"var y = base.dists.logistic.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.logistic.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.logistic.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.logistic.quantile( NaN, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.0, NaN, 1.0 )\ny = base.dists.logistic.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.quantile( 0.5, 0.0, -1.0 )\n","base.dists.logistic.skewness":"var y = base.dists.logistic.skewness( 0.0, 1.0 )\ny = base.dists.logistic.skewness( 4.0, 2.0 )\ny = base.dists.logistic.skewness( NaN, 1.0 )\ny = base.dists.logistic.skewness( 0.0, NaN )\ny = base.dists.logistic.skewness( 0.0, 0.0 )\n","base.dists.logistic.stdev":"var y = base.dists.logistic.stdev( 0.0, 1.0 )\ny = base.dists.logistic.stdev( 4.0, 2.0 )\ny = base.dists.logistic.stdev( NaN, 1.0 )\ny = base.dists.logistic.stdev( 0.0, NaN )\ny = base.dists.logistic.stdev( 0.0, 0.0 )\n","base.dists.logistic.variance":"var y = base.dists.logistic.variance( 0.0, 1.0 )\ny = base.dists.logistic.variance( 4.0, 2.0 )\ny = base.dists.logistic.variance( NaN, 1.0 )\ny = base.dists.logistic.variance( 0.0, NaN )\ny = base.dists.logistic.variance( 0.0, 0.0 )\n","base.dists.lognormal.cdf":"var y = base.dists.lognormal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, NaN )\ny = base.dists.lognormal.cdf( 2.0, NaN, 1.0 )\ny = base.dists.lognormal.cdf( NaN, 0.0, 1.0 )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.cdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, 0.0 )\n","base.dists.lognormal.entropy":"var y = base.dists.lognormal.entropy( 0.0, 1.0 )\ny = base.dists.lognormal.entropy( 5.0, 2.0 )\ny = base.dists.lognormal.entropy( NaN, 1.0 )\ny = base.dists.lognormal.entropy( 0.0, NaN )\ny = base.dists.lognormal.entropy( 0.0, 0.0 )\n","base.dists.lognormal.kurtosis":"var y = base.dists.lognormal.kurtosis( 0.0, 1.0 )\ny = base.dists.lognormal.kurtosis( 5.0, 2.0 )\ny = base.dists.lognormal.kurtosis( NaN, 1.0 )\ny = base.dists.lognormal.kurtosis( 0.0, NaN )\ny = base.dists.lognormal.kurtosis( 0.0, 0.0 )\n","base.dists.lognormal.LogNormal":"var lognormal = base.dists.lognormal.LogNormal( -2.0, 3.0 );\nlognormal.mu\nlognormal.sigma\nlognormal.entropy\nlognormal.kurtosis\nlognormal.mean\nlognormal.median\nlognormal.mode\nlognormal.skewness\nlognormal.stdev\nlognormal.variance\nlognormal.cdf( 0.8 )\nlognormal.logpdf( 2.0 )\nlognormal.pdf( 2.0 )\nlognormal.quantile( 0.9 )\n","base.dists.lognormal.logpdf":"var y = base.dists.lognormal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.logpdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.logpdf( 2.0, 0.0, 0.0 )\n","base.dists.lognormal.mean":"var y = base.dists.lognormal.mean( 0.0, 1.0 )\ny = base.dists.lognormal.mean( 4.0, 2.0 )\ny = base.dists.lognormal.mean( NaN, 1.0 )\ny = base.dists.lognormal.mean( 0.0, NaN )\ny = base.dists.lognormal.mean( 0.0, 0.0 )\n","base.dists.lognormal.median":"var y = base.dists.lognormal.median( 0.0, 1.0 )\ny = base.dists.lognormal.median( 5.0, 2.0 )\ny = base.dists.lognormal.median( NaN, 1.0 )\ny = base.dists.lognormal.median( 0.0, NaN )\ny = base.dists.lognormal.median( 0.0, 0.0 )\n","base.dists.lognormal.mode":"var y = base.dists.lognormal.mode( 0.0, 1.0 )\ny = base.dists.lognormal.mode( 5.0, 2.0 )\ny = base.dists.lognormal.mode( NaN, 1.0 )\ny = base.dists.lognormal.mode( 0.0, NaN )\ny = base.dists.lognormal.mode( 0.0, 0.0 )\n","base.dists.lognormal.pdf":"var y = base.dists.lognormal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.pdf( 2.0, 0.0, 0.0 )\n","base.dists.lognormal.quantile":"var y = base.dists.lognormal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.lognormal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.quantile( 0.5, 0.0, -1.0 )\ny = base.dists.lognormal.quantile( 0.5, 0.0, 0.0 )\n","base.dists.lognormal.skewness":"var y = base.dists.lognormal.skewness( 0.0, 1.0 )\ny = base.dists.lognormal.skewness( 5.0, 2.0 )\ny = base.dists.lognormal.skewness( NaN, 1.0 )\ny = base.dists.lognormal.skewness( 0.0, NaN )\ny = base.dists.lognormal.skewness( 0.0, 0.0 )\n","base.dists.lognormal.stdev":"var y = base.dists.lognormal.stdev( 0.0, 1.0 )\ny = base.dists.lognormal.stdev( 4.0, 2.0 )\ny = base.dists.lognormal.stdev( NaN, 1.0 )\ny = base.dists.lognormal.stdev( 0.0, NaN )\ny = base.dists.lognormal.stdev( 0.0, 0.0 )\n","base.dists.lognormal.variance":"var y = base.dists.lognormal.variance( 0.0, 1.0 )\ny = base.dists.lognormal.variance( 4.0, 2.0 )\ny = base.dists.lognormal.variance( NaN, 1.0 )\ny = base.dists.lognormal.variance( 0.0, NaN )\ny = base.dists.lognormal.variance( 0.0, 0.0 )\n","base.dists.negativeBinomial.cdf":"var y = base.dists.negativeBinomial.cdf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.cdf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.cdf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.cdf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.cdf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, 1.5 )\n","base.dists.negativeBinomial.kurtosis":"var v = base.dists.negativeBinomial.kurtosis( 100, 0.2 )\nv = base.dists.negativeBinomial.kurtosis( 20, 0.5 )\n","base.dists.negativeBinomial.logpmf":"var y = base.dists.negativeBinomial.logpmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.logpmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 20.0, NaN )\n","base.dists.negativeBinomial.mean":"var v = base.dists.negativeBinomial.mean( 100, 0.2 )\nv = base.dists.negativeBinomial.mean( 20, 0.5 )\n","base.dists.negativeBinomial.mgf":"var y = base.dists.negativeBinomial.mgf( 0.05, 20.0, 0.8 )\ny = base.dists.negativeBinomial.mgf( 0.1, 20.0, 0.1 )\ny = base.dists.negativeBinomial.mgf( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.mgf( 0.1, 0.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.1, -2.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, -1.0 )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, 1.5 )\n","base.dists.negativeBinomial.mode":"var v = base.dists.negativeBinomial.mode( 100, 0.2 )\nv = base.dists.negativeBinomial.mode( 20, 0.5 )\n","base.dists.negativeBinomial.NegativeBinomial":"var nbinomial = base.dists.negativeBinomial.NegativeBinomial( 8.0, 0.5 );\nnbinomial.r\nnbinomial.p\nnbinomial.kurtosis\nnbinomial.mean\nnbinomial.mode\nnbinomial.skewness\nnbinomial.stdev\nnbinomial.variance\nnbinomial.cdf( 2.9 )\nnbinomial.logpmf( 3.0 )\nnbinomial.mgf( 0.2 )\nnbinomial.pmf( 3.0 )\nnbinomial.quantile( 0.8 )\n","base.dists.negativeBinomial.pmf":"var y = base.dists.negativeBinomial.pmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.pmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.pmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.pmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.pmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.pmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, 20.0, NaN )\n","base.dists.negativeBinomial.quantile":"var y = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.2 )\ny = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.8 )\ny = base.dists.negativeBinomial.quantile( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.quantile( 1.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( -0.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.quantile( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.5, 0.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, -1.0 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, 1.5 )\ny = base.dists.negativeBinomial.quantile( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, NaN, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, NaN )\n","base.dists.negativeBinomial.skewness":"var v = base.dists.negativeBinomial.skewness( 100, 0.2 )\nv = base.dists.negativeBinomial.skewness( 20, 0.5 )\n","base.dists.negativeBinomial.stdev":"var v = base.dists.negativeBinomial.stdev( 100, 0.2 )\nv = base.dists.negativeBinomial.stdev( 20, 0.5 )\n","base.dists.negativeBinomial.variance":"var v = base.dists.negativeBinomial.variance( 100, 0.2 )\nv = base.dists.negativeBinomial.variance( 20, 0.5 )\n","base.dists.normal.cdf":"var y = base.dists.normal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.cdf( -1.0, -1.0, 2.0 )\ny = base.dists.normal.cdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.cdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.cdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.cdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.cdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 10.0, 8.0, 0.0 )\n","base.dists.normal.entropy":"var y = base.dists.normal.entropy( 0.0, 1.0 )\ny = base.dists.normal.entropy( 4.0, 3.0 )\ny = base.dists.normal.entropy( NaN, 1.0 )\ny = base.dists.normal.entropy( 0.0, NaN )\ny = base.dists.normal.entropy( 0.0, 0.0 )\n","base.dists.normal.kurtosis":"var y = base.dists.normal.kurtosis( 0.0, 1.0 )\ny = base.dists.normal.kurtosis( 4.0, 3.0 )\ny = base.dists.normal.kurtosis( NaN, 1.0 )\ny = base.dists.normal.kurtosis( 0.0, NaN )\ny = base.dists.normal.kurtosis( 0.0, 0.0 )\n","base.dists.normal.logpdf":"var y = base.dists.normal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.logpdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.logpdf( 8.0, 8.0, 0.0 )\n","base.dists.normal.mean":"var y = base.dists.normal.mean( 0.0, 1.0 )\ny = base.dists.normal.mean( 4.0, 2.0 )\ny = base.dists.normal.mean( NaN, 1.0 )\ny = base.dists.normal.mean( 0.0, NaN )\ny = base.dists.normal.mean( 0.0, 0.0 )\n","base.dists.normal.median":"var y = base.dists.normal.median( 0.0, 1.0 )\ny = base.dists.normal.median( 4.0, 2.0 )\ny = base.dists.normal.median( NaN, 1.0 )\ny = base.dists.normal.median( 0.0, NaN )\ny = base.dists.normal.median( 0.0, 0.0 )\n","base.dists.normal.mgf":"var y = base.dists.normal.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.mgf( NaN, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, NaN, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, NaN )\ny = base.dists.normal.mgf( 2.0, 0.0, 0.0 )\n","base.dists.normal.mode":"var y = base.dists.normal.mode( 0.0, 1.0 )\ny = base.dists.normal.mode( 4.0, 2.0 )\ny = base.dists.normal.mode( NaN, 1.0 )\ny = base.dists.normal.mode( 0.0, NaN )\ny = base.dists.normal.mode( 0.0, 0.0 )\n","base.dists.normal.Normal":"var normal = base.dists.normal.Normal( -2.0, 3.0 );\nnormal.mu\nnormal.sigma\nnormal.entropy\nnormal.kurtosis\nnormal.mean\nnormal.median\nnormal.mode\nnormal.skewness\nnormal.stdev\nnormal.variance\nnormal.cdf( 0.8 )\nnormal.logpdf( 2.0 )\nnormal.mgf( 0.2 )\nnormal.pdf( 2.0 )\nnormal.quantile( 0.9 )\n","base.dists.normal.pdf":"var y = base.dists.normal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.pdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.pdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.pdf( 8.0, 8.0, 0.0 )\n","base.dists.normal.quantile":"var y = base.dists.normal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.normal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.normal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.normal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.normal.quantile( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.quantile( 0.5, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.quantile( 0.3, 8.0, 0.0 )\ny = base.dists.normal.quantile( 0.9, 8.0, 0.0 )\n","base.dists.normal.skewness":"var y = base.dists.normal.skewness( 0.0, 1.0 )\ny = base.dists.normal.skewness( 4.0, 3.0 )\ny = base.dists.normal.skewness( NaN, 1.0 )\ny = base.dists.normal.skewness( 0.0, NaN )\ny = base.dists.normal.skewness( 0.0, 0.0 )\n","base.dists.normal.stdev":"var y = base.dists.normal.stdev( 0.0, 1.0 )\ny = base.dists.normal.stdev( 4.0, 3.0 )\ny = base.dists.normal.stdev( NaN, 1.0 )\ny = base.dists.normal.stdev( 0.0, NaN )\ny = base.dists.normal.stdev( 0.0, 0.0 )\n","base.dists.normal.variance":"var y = base.dists.normal.variance( 0.0, 1.0 )\ny = base.dists.normal.variance( 4.0, 3.0 )\ny = base.dists.normal.variance( NaN, 1.0 )\ny = base.dists.normal.variance( 0.0, NaN )\ny = base.dists.normal.variance( 0.0, 0.0 )\n","base.dists.pareto1.cdf":"var y = base.dists.pareto1.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.cdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.cdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, 1.0, NaN )\n","base.dists.pareto1.entropy":"var v = base.dists.pareto1.entropy( 0.8, 1.0 )\nv = base.dists.pareto1.entropy( 4.0, 12.0 )\nv = base.dists.pareto1.entropy( 8.0, 2.0 )\n","base.dists.pareto1.kurtosis":"var v = base.dists.pareto1.kurtosis( 5.0, 1.0 )\nv = base.dists.pareto1.kurtosis( 4.5, 12.0 )\nv = base.dists.pareto1.kurtosis( 8.0, 2.0 )\n","base.dists.pareto1.logcdf":"var y = base.dists.pareto1.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.logcdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, 1.0, NaN )\n","base.dists.pareto1.logpdf":"var y = base.dists.pareto1.logpdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.logpdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.logpdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.logpdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, 1.0, NaN )\n","base.dists.pareto1.mean":"var v = base.dists.pareto1.mean( 0.8, 1.0 )\nv = base.dists.pareto1.mean( 4.0, 12.0 )\nv = base.dists.pareto1.mean( 8.0, 2.0 )\n","base.dists.pareto1.median":"var v = base.dists.pareto1.median( 0.8, 1.0 )\nv = base.dists.pareto1.median( 4.0, 12.0 )\nv = base.dists.pareto1.median( 8.0, 2.0 )\n","base.dists.pareto1.mode":"var v = base.dists.pareto1.mode( 0.8, 1.0 )\nv = base.dists.pareto1.mode( 4.0, 12.0 )\nv = base.dists.pareto1.mode( 8.0, 2.0 )\n","base.dists.pareto1.Pareto1":"var pareto1 = base.dists.pareto1.Pareto1( 6.0, 5.0 );\npareto1.alpha\npareto1.beta\npareto1.entropy\npareto1.kurtosis\npareto1.mean\npareto1.median\npareto1.mode\npareto1.skewness\npareto1.variance\npareto1.cdf( 7.0 )\npareto1.logcdf( 7.0 )\npareto1.logpdf( 5.0 )\npareto1.pdf( 5.0 )\npareto1.quantile( 0.8 )\n","base.dists.pareto1.pdf":"var y = base.dists.pareto1.pdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.pdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.pdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.pdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.pdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, 1.0, NaN )\n","base.dists.pareto1.quantile":"var y = base.dists.pareto1.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.8, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 0.1, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, NaN )\ny = base.dists.pareto1.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, -1.0 )\n","base.dists.pareto1.skewness":"var v = base.dists.pareto1.skewness( 3.5, 1.0 )\nv = base.dists.pareto1.skewness( 4.0, 12.0 )\nv = base.dists.pareto1.skewness( 8.0, 2.0 )\n","base.dists.pareto1.variance":"var v = base.dists.pareto1.variance( 0.8, 1.0 )\nv = base.dists.pareto1.variance( 4.0, 12.0 )\nv = base.dists.pareto1.variance( 8.0, 2.0 )\n","base.dists.poisson.cdf":"var y = base.dists.poisson.cdf( 2.0, 0.5 )\ny = base.dists.poisson.cdf( 2.0, 10.0 )\ny = base.dists.poisson.cdf( -1.0, 4.0 )\ny = base.dists.poisson.cdf( NaN, 1.0 )\ny = base.dists.poisson.cdf( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.cdf( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.cdf( -2.0, 0.0 )\ny = base.dists.poisson.cdf( 0.0, 0.0 )\ny = base.dists.poisson.cdf( 10.0, 0.0 )\n","base.dists.poisson.entropy":"var v = base.dists.poisson.entropy( 11.0 )\nv = base.dists.poisson.entropy( 4.5 )\n","base.dists.poisson.kurtosis":"var v = base.dists.poisson.kurtosis( 11.0 )\nv = base.dists.poisson.kurtosis( 4.5 )\n","base.dists.poisson.logpmf":"var y = base.dists.poisson.logpmf( 4.0, 3.0 )\ny = base.dists.poisson.logpmf( 1.0, 3.0 )\ny = base.dists.poisson.logpmf( -1.0, 2.0 )\ny = base.dists.poisson.logpmf( 0.0, NaN )\ny = base.dists.poisson.logpmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.logpmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.logpmf( 2.0, 0.0 )\ny = base.dists.poisson.logpmf( 0.0, 0.0 )\n","base.dists.poisson.mean":"var v = base.dists.poisson.mean( 11.0 )\nv = base.dists.poisson.mean( 4.5 )\n","base.dists.poisson.median":"var v = base.dists.poisson.median( 11.0 )\nv = base.dists.poisson.median( 4.5 )\n","base.dists.poisson.mode":"var v = base.dists.poisson.mode( 11.0 )\nv = base.dists.poisson.mode( 4.5 )\n","base.dists.poisson.pmf":"var y = base.dists.poisson.pmf( 4.0, 3.0 )\ny = base.dists.poisson.pmf( 1.0, 3.0 )\ny = base.dists.poisson.pmf( -1.0, 2.0 )\ny = base.dists.poisson.pmf( 0.0, NaN )\ny = base.dists.poisson.pmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.pmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.pmf( 2.0, 0.0 )\ny = base.dists.poisson.pmf( 0.0, 0.0 )\n","base.dists.poisson.Poisson":"var poisson = base.dists.poisson.Poisson( 6.0 );\npoisson.lambda\npoisson.entropy\npoisson.kurtosis\npoisson.mean\npoisson.median\npoisson.mode\npoisson.skewness\npoisson.stdev\npoisson.variance\npoisson.cdf( 4.0 )\npoisson.logpmf( 2.0 )\npoisson.mgf( 0.5 )\npoisson.pmf( 2.0 )\npoisson.quantile( 0.5 )\n","base.dists.poisson.quantile":"var y = base.dists.poisson.quantile( 0.5, 2.0 )\ny = base.dists.poisson.quantile( 0.9, 4.0 )\ny = base.dists.poisson.quantile( 0.1, 200.0 )\ny = base.dists.poisson.quantile( 1.1, 0.0 )\ny = base.dists.poisson.quantile( -0.2, 0.0 )\ny = base.dists.poisson.quantile( NaN, 0.5 )\ny = base.dists.poisson.quantile( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.quantile( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.quantile( 0.1, 0.0 )\ny = base.dists.poisson.quantile( 0.9, 0.0 )\n","base.dists.poisson.skewness":"var v = base.dists.poisson.skewness( 11.0 )\nv = base.dists.poisson.skewness( 4.5 )\n","base.dists.poisson.stdev":"var v = base.dists.poisson.stdev( 11.0 )\nv = base.dists.poisson.stdev( 4.5 )\n","base.dists.poisson.variance":"var v = base.dists.poisson.variance( 11.0 )\nv = base.dists.poisson.variance( 4.5 )\n","base.dists.rayleigh.cdf":"var y = base.dists.rayleigh.cdf( 2.0, 3.0 )\ny = base.dists.rayleigh.cdf( 1.0, 2.0 )\ny = base.dists.rayleigh.cdf( -1.0, 4.0 )\ny = base.dists.rayleigh.cdf( NaN, 1.0 )\ny = base.dists.rayleigh.cdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.cdf( -2.0, 0.0 )\ny = base.dists.rayleigh.cdf( 0.0, 0.0 )\ny = base.dists.rayleigh.cdf( 2.0, 0.0 )\n","base.dists.rayleigh.entropy":"var v = base.dists.rayleigh.entropy( 11.0 )\nv = base.dists.rayleigh.entropy( 4.5 )\n","base.dists.rayleigh.kurtosis":"var v = base.dists.rayleigh.kurtosis( 11.0 )\nv = base.dists.rayleigh.kurtosis( 4.5 )\n","base.dists.rayleigh.logcdf":"var y = base.dists.rayleigh.logcdf( 2.0, 3.0 )\ny = base.dists.rayleigh.logcdf( 1.0, 2.0 )\ny = base.dists.rayleigh.logcdf( -1.0, 4.0 )\ny = base.dists.rayleigh.logcdf( NaN, 1.0 )\ny = base.dists.rayleigh.logcdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logcdf( 2.0, -1.0 )\n","base.dists.rayleigh.logpdf":"var y = base.dists.rayleigh.logpdf( 0.3, 1.0 )\ny = base.dists.rayleigh.logpdf( 2.0, 0.8 )\ny = base.dists.rayleigh.logpdf( -1.0, 0.5 )\ny = base.dists.rayleigh.logpdf( 0.0, NaN )\ny = base.dists.rayleigh.logpdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logpdf( 2.0, -1.0 )\n","base.dists.rayleigh.mean":"var v = base.dists.rayleigh.mean( 11.0 )\nv = base.dists.rayleigh.mean( 4.5 )\n","base.dists.rayleigh.median":"var v = base.dists.rayleigh.median( 11.0 )\nv = base.dists.rayleigh.median( 4.5 )\n","base.dists.rayleigh.mgf":"var y = base.dists.rayleigh.mgf( 1.0, 3.0 )\ny = base.dists.rayleigh.mgf( 1.0, 2.0 )\ny = base.dists.rayleigh.mgf( -1.0, 4.0 )\ny = base.dists.rayleigh.mgf( NaN, 1.0 )\ny = base.dists.rayleigh.mgf( 0.0, NaN )\ny = base.dists.rayleigh.mgf( 0.5, -1.0 )\n","base.dists.rayleigh.mode":"var v = base.dists.rayleigh.mode( 11.0 )\nv = base.dists.rayleigh.mode( 4.5 )\n","base.dists.rayleigh.pdf":"var y = base.dists.rayleigh.pdf( 0.3, 1.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.8 )\ny = base.dists.rayleigh.pdf( -1.0, 0.5 )\ny = base.dists.rayleigh.pdf( 0.0, NaN )\ny = base.dists.rayleigh.pdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.pdf( -2.0, 0.0 )\ny = base.dists.rayleigh.pdf( 0.0, 0.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.0 )\n","base.dists.rayleigh.quantile":"var y = base.dists.rayleigh.quantile( 0.8, 1.0 )\ny = base.dists.rayleigh.quantile( 0.5, 4.0 )\ny = base.dists.rayleigh.quantile( 1.1, 1.0 )\ny = base.dists.rayleigh.quantile( -0.2, 1.0 )\ny = base.dists.rayleigh.quantile( NaN, 1.0 )\ny = base.dists.rayleigh.quantile( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.quantile( 0.5, -1.0 )\n","base.dists.rayleigh.Rayleigh":"var rayleigh = base.dists.rayleigh.Rayleigh( 6.0 );\nrayleigh.sigma\nrayleigh.entropy\nrayleigh.kurtosis\nrayleigh.mean\nrayleigh.median\nrayleigh.mode\nrayleigh.skewness\nrayleigh.stdev\nrayleigh.variance\nrayleigh.cdf( 1.0 )\nrayleigh.logcdf( 1.0 )\nrayleigh.logpdf( 1.5 )\nrayleigh.mgf( -0.5 )\nrayleigh.pdf( 1.5 )\nrayleigh.quantile( 0.5 )\n","base.dists.rayleigh.skewness":"var v = base.dists.rayleigh.skewness( 11.0 )\nv = base.dists.rayleigh.skewness( 4.5 )\n","base.dists.rayleigh.stdev":"var v = base.dists.rayleigh.stdev( 9.0 )\nv = base.dists.rayleigh.stdev( 4.5 )\n","base.dists.rayleigh.variance":"var v = base.dists.rayleigh.variance( 9.0 )\nv = base.dists.rayleigh.variance( 4.5 )\n","base.dists.t.cdf":"var y = base.dists.t.cdf( 2.0, 0.1 )\ny = base.dists.t.cdf( 1.0, 2.0 )\ny = base.dists.t.cdf( -1.0, 4.0 )\ny = base.dists.t.cdf( NaN, 1.0 )\ny = base.dists.t.cdf( 0.0, NaN )\ny = base.dists.t.cdf( 2.0, -1.0 )\n","base.dists.t.entropy":"var v = base.dists.t.entropy( 11.0 )\nv = base.dists.t.entropy( 4.5 )\n","base.dists.t.kurtosis":"var v = base.dists.t.kurtosis( 11.0 )\nv = base.dists.t.kurtosis( 4.5 )\n","base.dists.t.mean":"var v = base.dists.t.mean( 11.0 )\nv = base.dists.t.mean( 4.5 )\n","base.dists.t.median":"var v = base.dists.t.median( 11.0 )\nv = base.dists.t.median( 4.5 )\n","base.dists.t.mode":"var v = base.dists.t.mode( 11.0 )\nv = base.dists.t.mode( 4.5 )\n","base.dists.t.pdf":"var y = base.dists.t.pdf( 0.3, 4.0 )\ny = base.dists.t.pdf( 2.0, 0.7 )\ny = base.dists.t.pdf( -1.0, 0.5 )\ny = base.dists.t.pdf( 0.0, NaN )\ny = base.dists.t.pdf( NaN, 2.0 )\ny = base.dists.t.pdf( 2.0, -1.0 )\n","base.dists.t.quantile":"var y = base.dists.t.quantile( 0.8, 1.0 )\ny = base.dists.t.quantile( 0.1, 1.0 )\ny = base.dists.t.quantile( 0.5, 0.1 )\ny = base.dists.t.quantile( -0.2, 0.1 )\ny = base.dists.t.quantile( NaN, 1.0 )\ny = base.dists.t.quantile( 0.0, NaN )\ny = base.dists.t.quantile( 0.5, -1.0 )\n","base.dists.t.skewness":"var v = base.dists.t.skewness( 11.0 )\nv = base.dists.t.skewness( 4.5 )\n","base.dists.t.stdev":"var v = base.dists.t.stdev( 9.0 )\nv = base.dists.t.stdev( 4.5 )\n","base.dists.t.T":"var t = base.dists.t.T( 6.0 );\nt.v\nt.entropy\nt.kurtosis\nt.mean\nt.median\nt.mode\nt.skewness\nt.stdev\nt.variance\nt.cdf( 1.0 )\nt.logcdf( 1.0 )\nt.logpdf( 1.5 )\nt.pdf( 1.5 )\nt.quantile( 0.8 )\n","base.dists.t.variance":"var v = base.dists.t.variance( 9.0 )\nv = base.dists.t.variance( 4.5 )\n","base.dists.triangular.cdf":"var y = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.cdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, 1.5 )\n","base.dists.triangular.entropy":"var v = base.dists.triangular.entropy( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.entropy( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.entropy( 2.0, 8.0, 5.0 )\n","base.dists.triangular.kurtosis":"var v = base.dists.triangular.kurtosis( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.kurtosis( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.kurtosis( 2.0, 8.0, 5.0 )\n","base.dists.triangular.logcdf":"var y = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logcdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, 1.5 )\n","base.dists.triangular.logpdf":"var y = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logpdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, 1.5 )\n","base.dists.triangular.mean":"var v = base.dists.triangular.mean( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mean( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mean( 2.0, 8.0, 5.0 )\n","base.dists.triangular.median":"var v = base.dists.triangular.median( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.median( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.median( 2.0, 8.0, 5.0 )\n","base.dists.triangular.mgf":"var y = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( -0.3, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.mgf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, NaN )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, 1.5 )\n","base.dists.triangular.mode":"var v = base.dists.triangular.mode( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mode( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mode( 2.0, 8.0, 5.0 )\n","base.dists.triangular.pdf":"var y = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.pdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, 1.5 )\n","base.dists.triangular.quantile":"var y = base.dists.triangular.quantile( 0.9, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( 0.1, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.1, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.quantile( 0.8, 0.0, 20.0, 0.0 )\ny = base.dists.triangular.quantile( 1.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( -0.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, NaN, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 0.0, NaN, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, NaN )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, 1.5 )\n","base.dists.triangular.skewness":"var v = base.dists.triangular.skewness( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.skewness( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.skewness( 2.0, 8.0, 5.0 )\n","base.dists.triangular.stdev":"var v = base.dists.triangular.stdev( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.stdev( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.stdev( 2.0, 8.0, 5.0 )\n","base.dists.triangular.Triangular":"var triangular = base.dists.triangular.Triangular( 0.0, 1.0, 0.5 );\ntriangular.a\ntriangular.b\ntriangular.c\ntriangular.entropy\ntriangular.kurtosis\ntriangular.mean\ntriangular.median\ntriangular.mode\ntriangular.skewness\ntriangular.stdev\ntriangular.variance\ntriangular.cdf( 0.8 )\ntriangular.logcdf( 0.8 )\ntriangular.logpdf( 0.8 )\ntriangular.mgf( 0.8 )\ntriangular.pdf( 0.8 )\ntriangular.quantile( 0.8 )\n","base.dists.triangular.variance":"var v = base.dists.triangular.variance( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.variance( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.variance( 2.0, 8.0, 5.0 )\n","base.dists.uniform.cdf":"var y = base.dists.uniform.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.cdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.cdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.cdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.cdf( 2.0, 1.0, 0.0 )\n","base.dists.uniform.entropy":"var v = base.dists.uniform.entropy( 0.0, 1.0 )\nv = base.dists.uniform.entropy( 4.0, 12.0 )\nv = base.dists.uniform.entropy( 2.0, 8.0 )\n","base.dists.uniform.kurtosis":"var v = base.dists.uniform.kurtosis( 0.0, 1.0 )\nv = base.dists.uniform.kurtosis( 4.0, 12.0 )\nv = base.dists.uniform.kurtosis( 2.0, 8.0 )\n","base.dists.uniform.logcdf":"var y = base.dists.uniform.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logcdf( 2.0, 1.0, 0.0 )\n","base.dists.uniform.logpdf":"var y = base.dists.uniform.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logpdf( 2.0, 3.0, 1.0 )\n","base.dists.uniform.mean":"var v = base.dists.uniform.mean( 0.0, 1.0 )\nv = base.dists.uniform.mean( 4.0, 12.0 )\nv = base.dists.uniform.mean( 2.0, 8.0 )\n","base.dists.uniform.median":"var v = base.dists.uniform.median( 0.0, 1.0 )\nv = base.dists.uniform.median( 4.0, 12.0 )\nv = base.dists.uniform.median( 2.0, 8.0 )\n","base.dists.uniform.mgf":"var y = base.dists.uniform.mgf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.mgf( -0.2, 0.0, 4.0 )\ny = base.dists.uniform.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 2.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 3.0 )\ny = base.dists.uniform.mgf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.mgf( 0.0, 0.0, NaN )\n","base.dists.uniform.pdf":"var y = base.dists.uniform.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.pdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.pdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.pdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.pdf( 2.0, 3.0, 1.0 )\n","base.dists.uniform.quantile":"var y = base.dists.uniform.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.uniform.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.uniform.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.uniform.quantile( NaN, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.0, NaN, 1.0 )\ny = base.dists.uniform.quantile( 0.0, 0.0, NaN )\ny = base.dists.uniform.quantile( 0.5, 2.0, 1.0 )\n","base.dists.uniform.skewness":"var v = base.dists.uniform.skewness( 0.0, 1.0 )\nv = base.dists.uniform.skewness( 4.0, 12.0 )\nv = base.dists.uniform.skewness( 2.0, 8.0 )\n","base.dists.uniform.stdev":"var v = base.dists.uniform.stdev( 0.0, 1.0 )\nv = base.dists.uniform.stdev( 4.0, 12.0 )\nv = base.dists.uniform.stdev( 2.0, 8.0 )\n","base.dists.uniform.Uniform":"var uniform = base.dists.uniform.Uniform( 0.0, 1.0 );\nuniform.a\nuniform.b\nuniform.entropy\nuniform.kurtosis\nuniform.mean\nuniform.median\nuniform.skewness\nuniform.stdev\nuniform.variance\nuniform.cdf( 0.8 )\nuniform.logcdf( 0.5 )\nuniform.logpdf( 1.0 )\nuniform.mgf( 0.8 )\nuniform.pdf( 0.8 )\nuniform.quantile( 0.8 )\n","base.dists.uniform.variance":"var v = base.dists.uniform.variance( 0.0, 1.0 )\nv = base.dists.uniform.variance( 4.0, 12.0 )\nv = base.dists.uniform.variance( 2.0, 8.0 )\n","base.dists.weibull.cdf":"var y = base.dists.weibull.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.cdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.cdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.cdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.cdf( 2.0, 0.0, -1.0 )\n","base.dists.weibull.entropy":"var v = base.dists.weibull.entropy( 1.0, 1.0 )\nv = base.dists.weibull.entropy( 4.0, 12.0 )\nv = base.dists.weibull.entropy( 8.0, 2.0 )\n","base.dists.weibull.kurtosis":"var v = base.dists.weibull.kurtosis( 1.0, 1.0 )\nv = base.dists.weibull.kurtosis( 4.0, 12.0 )\nv = base.dists.weibull.kurtosis( 8.0, 2.0 )\n","base.dists.weibull.logcdf":"var y = base.dists.weibull.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.logcdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logcdf( 2.0, 0.0, -1.0 )\n","base.dists.weibull.logpdf":"var y = base.dists.weibull.logpdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logpdf( 2.0, 0.0, -1.0 )\n","base.dists.weibull.mean":"var v = base.dists.weibull.mean( 1.0, 1.0 )\nv = base.dists.weibull.mean( 4.0, 12.0 )\nv = base.dists.weibull.mean( 8.0, 2.0 )\n","base.dists.weibull.median":"var v = base.dists.weibull.median( 1.0, 1.0 )\nv = base.dists.weibull.median( 4.0, 12.0 )\nv = base.dists.weibull.median( 8.0, 2.0 )\n","base.dists.weibull.mgf":"var y = base.dists.weibull.mgf( 1.0, 1.0, 0.5 )\ny = base.dists.weibull.mgf( -1.0, 4.0, 4.0 )\ny = base.dists.weibull.mgf( NaN, 1.0, 1.0 )\ny = base.dists.weibull.mgf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.mgf( 0.0, 1.0, NaN )\ny = base.dists.weibull.mgf( 0.2, -1.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.5, -1.0 )\ny = base.dists.weibull.mgf( 0.2, 0.5, 0.0 )\n","base.dists.weibull.mode":"var v = base.dists.weibull.mode( 1.0, 1.0 )\nv = base.dists.weibull.mode( 4.0, 12.0 )\nv = base.dists.weibull.mode( 8.0, 2.0 )\n","base.dists.weibull.pdf":"var y = base.dists.weibull.pdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.pdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.pdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.pdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.pdf( 2.0, 0.0, -1.0 )\n","base.dists.weibull.quantile":"var y = base.dists.weibull.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.weibull.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.weibull.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.weibull.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.weibull.quantile( NaN, 0.0, 1.0 )\ny = base.dists.weibull.quantile( 0.0, NaN, 1.0 )\ny = base.dists.weibull.quantile( 0.0, 0.0, NaN )\ny = base.dists.weibull.quantile( 0.5, 1.0, -1.0 )\n","base.dists.weibull.skewness":"var v = base.dists.weibull.skewness( 1.0, 1.0 )\nv = base.dists.weibull.skewness( 4.0, 12.0 )\nv = base.dists.weibull.skewness( 8.0, 2.0 )\n","base.dists.weibull.stdev":"var v = base.dists.weibull.stdev( 1.0, 1.0 )\nv = base.dists.weibull.stdev( 4.0, 12.0 )\nv = base.dists.weibull.stdev( 8.0, 2.0 )\n","base.dists.weibull.variance":"var v = base.dists.weibull.variance( 1.0, 1.0 )\nv = base.dists.weibull.variance( 4.0, 12.0 )\nv = base.dists.weibull.variance( 8.0, 2.0 )\n","base.dists.weibull.Weibull":"var weibull = base.dists.weibull.Weibull( 6.0, 5.0 );\nweibull.k\nweibull.lambda\nweibull.entropy\nweibull.kurtosis\nweibull.mean\nweibull.median\nweibull.mode\nweibull.skewness\nweibull.stdev\nweibull.variance\nweibull.cdf( 3.0 )\nweibull.logcdf( 3.0 )\nweibull.logpdf( 1.0 )\nweibull.mgf( -0.5 )\nweibull.pdf( 3.0 )\nweibull.quantile( 0.8 )\n","base.ellipe":"var y = base.ellipe( 0.5 )\ny = base.ellipe( -1.0 )\ny = base.ellipe( 2.0 )\ny = base.ellipe( PINF )\ny = base.ellipe( NINF )\ny = base.ellipe( NaN )\n","base.ellipk":"var y = base.ellipk( 0.5 )\ny = base.ellipk( -1.0 )\ny = base.ellipk( 2.0 )\ny = base.ellipk( PINF )\ny = base.ellipk( NINF )\ny = base.ellipk( NaN )\n","base.epsdiff":"var d = base.epsdiff( 12.15, 12.149999999999999 )\nd = base.epsdiff( 2.4341309458983933, 2.4341309458633909, 'mean-abs' )\n\n// Custom scale function:\nfunction scale( x, y ) { return ( x > y ) ? y : x; };\nd = base.epsdiff( 1.0000000000000002, 1.0000000000000100, scale )\n","base.erf":"var y = base.erf( 2.0 )\ny = base.erf( -1.0 )\ny = base.erf( -0.0 )\ny = base.erf( NaN )\n","base.erfc":"var y = base.erfc( 2.0 )\ny = base.erfc( -1.0 )\ny = base.erfc( 0.0 )\ny = base.erfc( PINF )\ny = base.erfc( NINF )\ny = base.erfc( NaN )\n","base.erfcinv":"var y = base.erfcinv( 0.5 )\ny = base.erfcinv( 0.8 )\ny = base.erfcinv( 0.0 )\ny = base.erfcinv( 2.0 )\ny = base.erfcinv( NaN )\n","base.erfinv":"var y = base.erfinv( 0.5 )\ny = base.erfinv( 0.8 )\ny = base.erfinv( 0.0 )\ny = base.erfinv( -0.0 )\ny = base.erfinv( -1.0 )\ny = base.erfinv( 1.0 )\ny = base.erfinv( NaN )\n","base.eta":"var y = base.eta( 0.0 )\ny = base.eta( -1.0 )\ny = base.eta( 1.0 )\ny = base.eta( 3.14 )\ny = base.eta( NaN )\n","base.evalpoly":"var arr = [ 3.0, 2.0, 1.0 ];\n\n// 3*10^0 + 2*10^1 + 1*10^2\nvar v = base.evalpoly( arr, 10.0 )\n","base.evalrational":"\n// 2x^3 + 4x^2 - 5x^1 - 6x^0\nvar P = [ -6.0, -5.0, 4.0, 2.0 ];\n\n// 0.5x^1 + 3x^0\nvar Q = [ 3.0, 0.5, 0.0, 0.0 ]; // zero-padded\n\n// Evaluate the rational function:\nvar v = base.evalrational( P, Q, 6.0 )\n","base.exp":"var y = base.exp( 4.0 )\ny = base.exp( -9.0 )\ny = base.exp( 0.0 )\ny = base.exp( NaN )\n","base.exp2":"var y = base.exp2( 3.0 )\ny = base.exp2( -9.0 )\ny = base.exp2( 0.0 )\ny = base.exp2( NaN )\n","base.exp10":"var y = base.exp10( 3.0 )\ny = base.exp10( -9.0 )\ny = base.exp10( 0.0 )\ny = base.exp10( NaN )\n","base.expit":"var y = base.expit( 0.0 )\ny = base.expit( 1.0 )\ny = base.expit( -1.0 )\ny = base.expit( Infinity )\ny = base.expit( NaN )\n","base.expm1":"var y = base.expm1( 0.2 )\ny = base.expm1( -9.0 )\ny = base.expm1( 0.0 )\ny = base.expm1( NaN )\n","base.expm1rel":"var y = base.expm1rel( 0.0 )\ny = base.expm1rel( 1.0 )\ny = base.expm1rel( -1.0 )\ny = base.expm1rel( NaN )\n","base.exponent":"var exponent = base.exponent( 3.14e-307 )\nexponent = base.exponent( -3.14 )\nexponent = base.exponent( 0.0 )\nexponent = base.exponent( NaN )\n","base.exponentf":"var exponent = base.exponentf( base.float64ToFloat32( 3.14e34 ) )\nexponent = base.exponentf( base.float64ToFloat32( 3.14e-34 ) )\nexponent = base.exponentf( base.float64ToFloat32( -3.14 ) )\nexponent = base.exponentf( 0.0 )\nexponent = base.exponentf( NaN )\n","base.factorial":"var y = base.factorial( 3.0 )\ny = base.factorial( -1.5 )\ny = base.factorial( -0.5 )\ny = base.factorial( 0.5 )\ny = base.factorial( -10.0 )\ny = base.factorial( 171.0 )\ny = base.factorial( NaN )\n","base.factorialln":"var y = base.factorialln( 3.0 )\ny = base.factorialln( 2.4 )\ny = base.factorialln( -1.0 )\ny = base.factorialln( -1.5 )\ny = base.factorialln( NaN )\n","base.fallingFactorial":"var v = base.fallingFactorial( 0.9, 5 )\nv = base.fallingFactorial( -9.0, 3 )\nv = base.fallingFactorial( 0.0, 2 )\nv = base.fallingFactorial( 3.0, -2 )\n","base.fibonacci":"var y = base.fibonacci( 0 )\ny = base.fibonacci( 1 )\ny = base.fibonacci( 2 )\ny = base.fibonacci( 3 )\ny = base.fibonacci( 4 )\ny = base.fibonacci( 79 )\ny = base.fibonacci( NaN )\n","base.fibonacciIndex":"var n = base.fibonacciIndex( 2 )\nn = base.fibonacciIndex( 3 )\nn = base.fibonacciIndex( 5 )\nn = base.fibonacciIndex( NaN )\nn = base.fibonacciIndex( 1 )\n","base.fibpoly":"\n// 2^4 + 3*2^2 + 1\nvar v = base.fibpoly( 5, 2.0 )\n","base.flipsign":"var z = base.flipsign( -3.14, 10.0 )\nz = base.flipsign( -3.14, -1.0 )\nz = base.flipsign( 1.0, -0.0 )\nz = base.flipsign( -3.14, -0.0 )\nz = base.flipsign( -0.0, 1.0 )\nz = base.flipsign( 0.0, -1.0 )\n","base.float32ToInt32":"var y = base.float32ToInt32( base.float64ToFloat32( 4294967295.0 ) )\ny = base.float32ToInt32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( NaN ) )\ny = base.float32ToInt32( FLOAT32_PINF )\ny = base.float32ToInt32( FLOAT32_NINF )\n","base.float32ToUint32":"var y = base.float32ToUint32( base.float64ToFloat32( 4294967297.0 ) )\ny = base.float32ToUint32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( NaN ) )\ny = base.float32ToUint32( FLOAT32_PINF )\ny = base.float32ToUint32( FLOAT32_NINF )\n","base.float64ToFloat32":"var y = base.float64ToFloat32( 1.337 )\n","base.float64ToInt32":"var y = base.float64ToInt32( 4294967295.0 )\ny = base.float64ToInt32( 3.14 )\ny = base.float64ToInt32( -3.14 )\ny = base.float64ToInt32( NaN )\ny = base.float64ToInt32( PINF )\ny = base.float64ToInt32( NINF )\n","base.float64ToUint32":"var y = base.float64ToUint32( 4294967297.0 )\ny = base.float64ToUint32( 3.14 )\ny = base.float64ToUint32( -3.14 )\ny = base.float64ToUint32( NaN )\ny = base.float64ToUint32( PINF )\ny = base.float64ToUint32( NINF )\n","base.floor":"var y = base.floor( 3.14 )\ny = base.floor( -4.2 )\ny = base.floor( -4.6 )\ny = base.floor( 9.5 )\ny = base.floor( -0.0 )\n","base.floor2":"var y = base.floor2( 3.14 )\ny = base.floor2( -4.2 )\ny = base.floor2( -4.6 )\ny = base.floor2( 9.5 )\ny = base.floor2( 13.0 )\ny = base.floor2( -13.0 )\ny = base.floor2( -0.0 )\n","base.floor10":"var y = base.floor10( 3.14 )\ny = base.floor10( -4.2 )\ny = base.floor10( -4.6 )\ny = base.floor10( 9.5 )\ny = base.floor10( 13.0 )\ny = base.floor10( -13.0 )\ny = base.floor10( -0.0 )\n","base.floorb":"\n// Round to 4 decimal places:\nvar y = base.floorb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.floorb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward negative infinity:\ny = base.floorb( 5.0, 1, 2 )\n","base.floorn":"\n// Round to 4 decimal places:\nvar y = base.floorn( 3.14159, -4 )\n\n// If `n = 0`, standard round toward negative infinity behavior:\ny = base.floorn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.floorn( 12368.0, 3 )\n","base.floorsd":"var y = base.floorsd( 3.14159, 5 )\ny = base.floorsd( 3.14159, 1 )\ny = base.floorsd( 12368.0, 2 )\ny = base.floorsd( 0.0313, 2, 2 )\n","base.fresnel":"var y = base.fresnel( 0.0 )\ny = base.fresnel( 1.0 )\ny = base.fresnel( PINF )\ny = base.fresnel( NINF )\ny = base.fresnel( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.fresnel( out, 0.0 )\nvar bool = ( v === out )\n","base.fresnelc":"var y = base.fresnelc( 0.0 )\ny = base.fresnelc( 1.0 )\ny = base.fresnelc( PINF )\ny = base.fresnelc( NINF )\ny = base.fresnelc( NaN )\n","base.fresnels":"var y = base.fresnels( 0.0 )\ny = base.fresnels( 1.0 )\ny = base.fresnels( PINF )\ny = base.fresnels( NINF )\ny = base.fresnels( NaN )\n","base.frexp":"var out = base.frexp( 4.0 )\nout = base.frexp( 0.0 )\nout = base.frexp( -0.0 )\nout = base.frexp( NaN )\nout = base.frexp( PINF )\nout = base.frexp( NINF )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar y = base.frexp( out, 4.0 )\nvar bool = ( y === out )\n","base.fromBinaryString":"var bstr;\nbstr = '0100000000010000000000000000000000000000000000000000000000000000';\nvar val = base.fromBinaryString( bstr )\nbstr = '0100000000001001001000011111101101010100010001000010110100011000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111100001110011001111001110000101111010111100100010100000';\nval = base.fromBinaryString( bstr )\n\n// The function handles subnormals:\nbstr = '1000000000000000000000000000000000000000000000000001100011010011';\nval = base.fromBinaryString( bstr )\nbstr = '0000000000000000000000000000000000000000000000000000000000000001';\nval = base.fromBinaryString( bstr )\n\n// The function handles special values:\nbstr = '0000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111111000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\n","base.fromBinaryStringf":"var bstr = '01000000100000000000000000000000';\nvar val = base.fromBinaryStringf( bstr )\nbstr = '01000000010010010000111111011011';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111011011000011101000110011';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles subnormals:\nbstr = '10000000000000000000000000010110';\nval = base.fromBinaryStringf( bstr )\nbstr = '00000000000000000000000000000001';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles special values:\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '10000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111110000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\n","base.fromBinaryStringUint8":"var bstr = '01010101';\nvar val = base.fromBinaryStringUint8( bstr )\nbstr = '00000000';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '00000010';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '11111111';\nval = base.fromBinaryStringUint8( bstr )\n","base.fromBinaryStringUint16":"var bstr = '0101010101010101';\nvar val = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000000';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000010';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '1111111111111111';\nval = base.fromBinaryStringUint16( bstr )\n","base.fromBinaryStringUint32":"var bstr = '01010101010101010101010101010101';\nvar val = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000010';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '11111111111111111111111111111111';\nval = base.fromBinaryStringUint32( bstr )\n","base.fromWordf":"var word = 1068180177; // => 0 01111111 01010110010001011010001\nvar f32 = base.fromWordf( word ) // when printed, promoted to float64\n","base.fromWords":"var v = base.fromWords( 1774486211, 2479577218 )\nv = base.fromWords( 3221823995, 1413754136 )\nv = base.fromWords( 0, 0 )\nv = base.fromWords( 2147483648, 0 )\nv = base.fromWords( 2146959360, 0 )\nv = base.fromWords( 2146435072, 0 )\nv = base.fromWords( 4293918720, 0 )\n","base.gamma":"var y = base.gamma( 4.0 )\ny = base.gamma( -1.5 )\ny = base.gamma( -0.5 )\ny = base.gamma( 0.5 )\ny = base.gamma( 0.0 )\ny = base.gamma( -0.0 )\ny = base.gamma( NaN )\n","base.gamma1pm1":"var y = base.gamma1pm1( 0.2 )\ny = base.gamma1pm1( -6.7 )\ny = base.gamma1pm1( 0.0 )\ny = base.gamma1pm1( NaN )\n","base.gammaDeltaRatio":"var y = base.gammaDeltaRatio( 2.0, 3.0 )\ny = base.gammaDeltaRatio( 4.0, 0.5 )\ny = base.gammaDeltaRatio( 100.0, 0.0 )\ny = base.gammaDeltaRatio( NaN, 3.0 )\ny = base.gammaDeltaRatio( 5.0, NaN )\ny = base.gammaDeltaRatio( NaN, NaN )\n","base.gammainc":"var y = base.gammainc( 6.0, 2.0 )\ny = base.gammainc( 1.0, 2.0, true, true )\ny = base.gammainc( 7.0, 5.0 )\ny = base.gammainc( 7.0, 5.0, false )\ny = base.gammainc( NaN, 2.0 )\ny = base.gammainc( 6.0, NaN )\n","base.gammaincinv":"var y = base.gammaincinv( 0.5, 2.0 )\ny = base.gammaincinv( 0.1, 10.0 )\ny = base.gammaincinv( 0.75, 3.0 )\ny = base.gammaincinv( 0.75, 3.0, true )\ny = base.gammaincinv( 0.75, NaN )\ny = base.gammaincinv( NaN, 3.0 )\n","base.gammaLanczosSum":"var y = base.gammaLanczosSum( 4.0 )\ny = base.gammaLanczosSum( -1.5 )\ny = base.gammaLanczosSum( -0.5 )\ny = base.gammaLanczosSum( 0.5 )\ny = base.gammaLanczosSum( 0.0 )\ny = base.gammaLanczosSum( NaN )\n","base.gammaLanczosSumExpGScaled":"var y = base.gammaLanczosSumExpGScaled( 4.0 )\ny = base.gammaLanczosSumExpGScaled( -1.5 )\ny = base.gammaLanczosSumExpGScaled( -0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.0 )\ny = base.gammaLanczosSumExpGScaled( NaN )\n","base.gammaln":"var y = base.gammaln( 1.0 )\ny = base.gammaln( 2.0 )\ny = base.gammaln( 4.0 )\ny = base.gammaln( -0.5 )\ny = base.gammaln( 0.5 )\ny = base.gammaln( 0.0 )\ny = base.gammaln( NaN )\n","base.gasum":"\n// Standard usage:\nvar x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];\nvar sum = base.gasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.gasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.gasum( N, x1, stride )\n","base.gaxpy":"\n// Standard usage:\nvar x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar y = [ 1.0, 1.0, 1.0, 1.0, 1.0 ];\nvar alpha = 5.0;\nbase.gaxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\nbase.gaxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gaxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n","base.gcd":"var v = base.gcd( 48, 18 )\n","base.gcopy":"\n// Standard usage:\nvar x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar y = [ 6.0, 7.0, 8.0, 9.0, 10.0 ];\nbase.gcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\ny = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\nvar N = base.floor( x.length / 2 );\nbase.gcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gcopy( N, x1, -2, y1, 1 )\ny0\n","base.getHighWord":"var w = base.getHighWord( 3.14e201 )\n","base.getLowWord":"var w = base.getLowWord( 3.14e201 )\n","base.hacovercos":"var y = base.hacovercos( 3.14 )\ny = base.hacovercos( -4.2 )\ny = base.hacovercos( -4.6 )\ny = base.hacovercos( 9.5 )\ny = base.hacovercos( -0.0 )\n","base.hacoversin":"var y = base.hacoversin( 3.14 )\ny = base.hacoversin( -4.2 )\ny = base.hacoversin( -4.6 )\ny = base.hacoversin( 9.5 )\ny = base.hacoversin( -0.0 )\n","base.havercos":"var y = base.havercos( 3.14 )\ny = base.havercos( -4.2 )\ny = base.havercos( -4.6 )\ny = base.havercos( 9.5 )\ny = base.havercos( -0.0 )\n","base.haversin":"var y = base.haversin( 3.14 )\ny = base.haversin( -4.2 )\ny = base.haversin( -4.6 )\ny = base.haversin( 9.5 )\ny = base.haversin( -0.0 )\n","base.heaviside":"var y = base.heaviside( 3.14 )\ny = base.heaviside( -3.14 )\ny = base.heaviside( 0.0 )\ny = base.heaviside( 0.0, 'half-maximum' )\ny = base.heaviside( 0.0, 'left-continuous' )\ny = base.heaviside( 0.0, 'right-continuous' )\n","base.hermitepoly":"var y = base.hermitepoly( 1, 0.5 )\ny = base.hermitepoly( -1, 0.5 )\ny = base.hermitepoly( 0, 0.5 )\ny = base.hermitepoly( 2, 0.5 )\n","base.hypot":"var h = base.hypot( -5.0, 12.0 )\nh = base.hypot( NaN, 12.0 )\nh = base.hypot( -0.0, -0.0 )\n","base.imul":"var v = base.imul( -10|0, 4|0 )\n","base.imuldw":"var v = base.imuldw( 1, 10 )\n","base.int32ToUint32":"var y = base.int32ToUint32( base.float64ToInt32( -32 ) )\ny = base.int32ToUint32( base.float64ToInt32( 3 ) )\n","base.inv":"var y = base.inv( -1.0 )\ny = base.inv( 2.0 )\ny = base.inv( 0.0 )\ny = base.inv( -0.0 )\ny = base.inv( NaN )\n","base.isEven":"var bool = base.isEven( 5.0 )\nbool = base.isEven( -2.0 )\nbool = base.isEven( 0.0 )\nbool = base.isEven( NaN )\n","base.isEvenInt32":"var bool = base.isEvenInt32( 5 )\nbool = base.isEvenInt32( -2 )\nbool = base.isEvenInt32( 0 )\n","base.isFinite":"var bool = base.isFinite( 5.0 )\nbool = base.isFinite( -2.0e64 )\nbool = base.isFinite( PINF )\nbool = base.isFinite( NINF )\n","base.isInfinite":"var bool = base.isInfinite( PINF )\nbool = base.isInfinite( NINF )\nbool = base.isInfinite( 5.0 )\nbool = base.isInfinite( NaN )\n","base.isInteger":"var bool = base.isInteger( 1.0 )\nbool = base.isInteger( 3.14 )\n","base.isnan":"var bool = base.isnan( NaN )\nbool = base.isnan( 7.0 )\n","base.isNegativeInteger":"var bool = base.isNegativeInteger( -1.0 )\nbool = base.isNegativeInteger( 0.0 )\nbool = base.isNegativeInteger( 10.0 )\n","base.isNegativeZero":"var bool = base.isNegativeZero( -0.0 )\nbool = base.isNegativeZero( 0.0 )\n","base.isNonNegativeInteger":"var bool = base.isNonNegativeInteger( 1.0 )\nbool = base.isNonNegativeInteger( 0.0 )\nbool = base.isNonNegativeInteger( -10.0 )\n","base.isNonPositiveInteger":"var bool = base.isNonPositiveInteger( -1.0 )\nbool = base.isNonPositiveInteger( 0.0 )\nbool = base.isNonPositiveInteger( 10.0 )\n","base.isOdd":"var bool = base.isOdd( 5.0 )\nbool = base.isOdd( -2.0 )\nbool = base.isOdd( 0.0 )\nbool = base.isOdd( NaN )\n","base.isOddInt32":"var bool = base.isOddInt32( 5 )\nbool = base.isOddInt32( -2 )\nbool = base.isOddInt32( 0 )\n","base.isPositiveInteger":"var bool = base.isPositiveInteger( 1.0 )\nbool = base.isPositiveInteger( 0.0 )\nbool = base.isPositiveInteger( -10.0 )\n","base.isPositiveZero":"var bool = base.isPositiveZero( 0.0 )\nbool = base.isPositiveZero( -0.0 )\n","base.isPow2Uint32":"var bool = base.isPow2Uint32( 2 )\nbool = base.isPow2Uint32( 5 )\n","base.isProbability":"var bool = base.isProbability( 0.5 )\nbool = base.isProbability( 3.14 )\nbool = base.isProbability( NaN )\n","base.isSafeInteger":"var bool = base.isSafeInteger( 1.0 )\nbool = base.isSafeInteger( 2.0e200 )\nbool = base.isSafeInteger( 3.14 )\n","base.kernelBetainc":"var out = base.kernelBetainc( 0.8, 1.0, 0.3, false, false )\nout = base.kernelBetainc( 0.2, 1.0, 2.0, true, false )\nout = new Array( 2 );\nvar v = base.kernelBetainc( out, 0.2, 1.0, 2.0, true, true )\nvar bool = ( v === out )\n","base.kernelBetaincinv":"var y = base.kernelBetaincinv( 3.0, 3.0, 0.2, 0.8 )\ny = base.kernelBetaincinv( 3.0, 3.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.8, 0.2 )\n","base.kernelCos":"var out = base.kernelCos( 0.0, 0.0 )\nout = base.kernelCos( PI/6.0, 0.0 )\nout = base.kernelCos( 0.785, -1.144e-17 )\nout = base.kernelCos( NaN )\n","base.kernelSin":"var y = base.kernelSin( 0.0, 0.0 )\ny = base.kernelSin( PI/6.0, 0.0 )\ny = base.kernelSin( 0.619, 9.279e-18 )\ny = base.kernelSin( NaN, 0.0 )\ny = base.kernelSin( 2.0, NaN )\ny = base.kernelSin( NaN, NaN )\n","base.kernelTan":"var out = base.kernelTan( PI/4.0, 0.0, 1 )\nout = base.kernelTan( PI/4.0, 0.0, -1 )\nout = base.kernelTan( PI/6.0, 0.0, 1 )\nout = base.kernelTan( 0.664, 5.288e-17, 1 )\nout = base.kernelTan( NaN, 0.0, 1 )\nout = base.kernelTan( 3.0, NaN, 1 )\nout = base.kernelTan( 3.0, 0.0, NaN )\n","base.kroneckerDelta":"var y = base.kroneckerDelta( 3.14, 0.0 )\ny = base.kroneckerDelta( 3.14, 3.14 )\n","base.lcm":"var v = base.lcm( 21, 6 )\n","base.ldexp":"var x = base.ldexp( 0.5, 3 )\nx = base.ldexp( 4.0, -2 )\nx = base.ldexp( 0.0, 20 )\nx = base.ldexp( -0.0, 39 )\nx = base.ldexp( NaN, -101 )\nx = base.ldexp( PINF, 11 )\nx = base.ldexp( NINF, -118 )\n","base.ln":"var y = base.ln( 4.0 )\ny = base.ln( 0.0 )\ny = base.ln( PINF )\ny = base.ln( NaN )\ny = base.ln( -4.0 )\n","base.log":"var y = base.log( 100.0, 10.0 )\ny = base.log( 16.0, 2.0 )\ny = base.log( 5.0, 1.0 )\ny = base.log( NaN, 2.0 )\ny = base.log( 1.0, NaN )\ny = base.log( -4.0, 2.0 )\ny = base.log( 4.0, -2.0 )\n","base.log1mexp":"var y = base.log1mexp( -10.0 )\ny = base.log1mexp( 0.0 )\ny = base.log1mexp( 5.0 )\ny = base.log1mexp( 10.0 )\ny = base.log1mexp( NaN )\n","base.log1p":"var y = base.log1p( 4.0 )\ny = base.log1p( -1.0 )\ny = base.log1p( 0.0 )\ny = base.log1p( -0.0 )\ny = base.log1p( -2.0 )\ny = base.log1p( NaN )\n","base.log1pexp":"var y = base.log1pexp( -10.0 )\ny = base.log1pexp( 0.0 )\ny = base.log1pexp( 5.0 )\ny = base.log1pexp( 34.0 )\ny = base.log1pexp( NaN )\n","base.log2":"var y = base.log2( 4.0 )\ny = base.log2( 8.0 )\ny = base.log2( 0.0 )\ny = base.log2( PINF )\ny = base.log2( NaN )\ny = base.log2( -4.0 )\n","base.log10":"var y = base.log10( 100.0 )\ny = base.log10( 8.0 )\ny = base.log10( 0.0 )\ny = base.log10( PINF )\ny = base.log10( NaN )\ny = base.log10( -4.0 )\n","base.logaddexp":"var v = base.logaddexp( 90.0, 90.0 )\nv = base.logaddexp( -20.0, 90.0 )\nv = base.logaddexp( 0.0, -100.0 )\nv = base.logaddexp( NaN, NaN )\n","base.logit":"var y = base.logit( 0.2 )\ny = base.logit( 0.9 )\ny = base.logit( -4.0 )\ny = base.logit( 1.5 )\ny = base.logit( NaN )\n","base.lucas":"var y = base.lucas( 0 )\ny = base.lucas( 1 )\ny = base.lucas( 2 )\ny = base.lucas( 3 )\ny = base.lucas( 4 )\ny = base.lucas( 77 )\ny = base.lucas( NaN )\n","base.lucaspoly":"\n// 2^5 + 5*2^3 + 5*2\nvar v = base.lucaspoly( 5, 2.0 )\n","base.max":"var v = base.max( 3.14, 4.2 )\nv = base.max( 5.9, 3.14, 4.2 )\nv = base.max( 3.14, NaN )\nv = base.max( +0.0, -0.0 )\n","base.maxabs":"var v = base.maxabs( 3.14, -4.2 )\nv = base.maxabs( 5.9, 3.14, 4.2 )\nv = base.maxabs( 3.14, NaN )\nv = base.maxabs( +0.0, -0.0 )\n","base.min":"var v = base.min( 3.14, 4.2 )\nv = base.min( 5.9, 3.14, 4.2 )\nv = base.min( 3.14, NaN )\nv = base.min( +0.0, -0.0 )\n","base.minabs":"var v = base.minabs( 3.14, -4.2 )\nv = base.minabs( 5.9, 3.14, 4.2 )\nv = base.minabs( 3.14, NaN )\nv = base.minabs( +0.0, -0.0 )\n","base.minmax":"var v = base.minmax( 3.14, 4.2 )\nv = base.minmax( 5.9, 3.14, 4.2 )\nv = base.minmax( 3.14, NaN )\nv = base.minmax( +0.0, -0.0 )\nv = base.minmax( 3.14 )\nvar out = new Array( 2 );\nv = base.minmax( out, 3.14 )\nvar bool = ( v === out )\n","base.minmaxabs":"var v = base.minmaxabs( 3.14, 4.2 )\nv = base.minmaxabs( -5.9, 3.14, 4.2 )\nv = base.minmaxabs( 3.14, NaN )\nv = base.minmaxabs( +0.0, -0.0 )\nv = base.minmaxabs( 3.14 )\nvar out = new Array( 2 );\nv = base.minmaxabs( out, 3.14 )\nvar bool = ( v === out )\n","base.modf":"var parts = base.modf( 3.14 )\nparts = base.modf( 3.14 )\nparts = base.modf( +0.0 )\nparts = base.modf( -0.0 )\nparts = base.modf( PINF )\nparts = base.modf( NINF )\nparts = base.modf( NaN )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\nparts = base.modf( out, 3.14 )\nvar bool = ( parts === out )\n","base.ndarray":"var ctor = base.ndarray( 'float64', 3 )\n\n// To create a new instance...\nvar b = [ 1, 2, 3, 4 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n","base.ndarrayMemoized":"var ctor = base.ndarrayMemoized( 'float64', 3 )\nvar f = base.ndarrayMemoized( 'float64', 3 )\nvar bool = ( f === ctor )\n\n// To create a new instance...\nvar b = [ 1, 2, 3, 4 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n","base.negafibonacci":"var y = base.negafibonacci( 0 )\ny = base.negafibonacci( -1 )\ny = base.negafibonacci( -2 )\ny = base.negafibonacci( -3 )\ny = base.negafibonacci( -4 )\ny = base.negafibonacci( -79 )\ny = base.negafibonacci( -80 )\ny = base.negafibonacci( NaN )\n","base.negalucas":"var y = base.negalucas( 0 )\ny = base.negalucas( -1 )\ny = base.negalucas( -2 )\ny = base.negalucas( -3 )\ny = base.negalucas( -4 )\ny = base.negalucas( -77 )\ny = base.negalucas( -78 )\ny = base.negalucas( NaN )\n","base.nonfibonacci":"var v = base.nonfibonacci( 1 )\nv = base.nonfibonacci( 2 )\nv = base.nonfibonacci( 3 )\nv = base.nonfibonacci( NaN )\n","base.normalize":"var out = base.normalize( 3.14e-319 )\nvar y = out[ 0 ];\nvar exponent = out[ 1 ];\nvar bool = ( y*base.pow(2.0, exponent) === 3.14e-319 )\n\n// Special cases:\nout = base.normalize( 0.0 )\nout = base.normalize( PINF )\nout = base.normalize( NINF )\nout = base.normalize( NaN )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nvar v = base.normalize( out, 3.14e-319 )\nbool = ( v === out )\n","base.normalizef":"var out = base.normalizef( base.float64ToFloat32( 1.401e-45 ) )\nvar y = out[ 0 ];\nvar exp = out[ 1 ];\nvar bool = ( y*base.pow(2,exp) === base.float64ToFloat32(1.401e-45) )\n\n// Special cases:\nout = base.normalizef( FLOAT32_PINF )\nout = base.normalizef( FLOAT32_NINF )\nout = base.normalizef( NaN )\n\n// Provide an output array:\nout = new Float32Array( 2 );\nvar v = base.normalizef( out, base.float64ToFloat32( 1.401e-45 ) )\nbool = ( v === out )\n","base.normhermitepoly":"var y = base.normhermitepoly( 1, 0.5 )\ny = base.normhermitepoly( -1, 0.5 )\ny = base.normhermitepoly( 0, 0.5 )\ny = base.normhermitepoly( 2, 0.5 )\n","base.pdiff":"var v = base.pdiff( 5.9, 3.14 )\nv = base.pdiff( 3.14, 4.2 )\nv = base.pdiff( 3.14, NaN )\nv = base.pdiff( -0.0, +0.0 )\n","base.polygamma":"var v = base.polygamma( 3, 1.2 )\nv = base.polygamma( 5, 1.2 )\nv = base.polygamma( 3, -4.9 )\nv = base.polygamma( -1, 5.3 )\nv = base.polygamma( 2, -1.0 )\n","base.pow":"var y = base.pow( 2.0, 3.0 )\ny = base.pow( 4.0, 0.5 )\ny = base.pow( 100.0, 0.0 )\ny = base.pow( PI, 5.0 )\ny = base.pow( PI, -0.2 )\ny = base.pow( NaN, 3.0 )\ny = base.pow( 5.0, NaN )\ny = base.pow( NaN, NaN )\n","base.powm1":"var y = base.powm1( 2.0, 3.0 )\ny = base.powm1( 4.0, 0.5 )\ny = base.powm1( 0.0, 100.0 )\ny = base.powm1( 100.0, 0.0 )\ny = base.powm1( 0.0, 0.0 )\ny = base.powm1( PI, 5.0 )\ny = base.powm1( NaN, 3.0 )\ny = base.powm1( 5.0, NaN )\n","base.rad2deg":"var d = base.rad2deg( PI/2.0 )\nd = base.rad2deg( -PI/4.0 )\nd = base.rad2deg( NaN )\n\n// Due to finite precision, canonical values may not be returned:\nd = base.rad2deg( PI/6.0 )\n","base.ramp":"var y = base.ramp( 3.14 )\ny = base.ramp( -3.14 )\n","base.random.arcsine":"var r = base.random.arcsine( 2.0, 5.0 )\n","base.random.bernoulli":"var r = base.random.bernoulli( 0.8 );\n","base.random.beta":"var r = base.random.beta( 2.0, 5.0 );\n","base.random.betaprime":"var r = base.random.betaprime( 2.0, 5.0 );\n","base.random.binomial":"var r = base.random.binomial( 20, 0.8 );\n","base.random.boxMuller":"var r = base.random.boxMuller();\n","base.random.cauchy":"var r = base.random.cauchy( 2.0, 5.0 );\n","base.random.chi":"var r = base.random.chi( 2 );\n","base.random.chisquare":"var r = base.random.chisquare( 2 );\n","base.random.cosine":"var r = base.random.cosine( 2.0, 5.0 );\n","base.random.discreteUniform":"var r = base.random.discreteUniform( 2, 50 );\n","base.random.erlang":"var r = base.random.erlang( 2, 5.0 );\n","base.random.exponential":"var r = base.random.exponential( 7.9 );\n","base.random.f":"var r = base.random.f( 2.0, 5.0 );\n","base.random.frechet":"var r = base.random.frechet( 2.0, 5.0, 3.33 );\n","base.random.gamma":"var r = base.random.gamma( 2.0, 5.0 );\n","base.random.geometric":"var r = base.random.geometric( 0.8 );\n","base.random.gumbel":"var r = base.random.gumbel( 2.0, 5.0 );\n","base.random.hypergeometric":"var r = base.random.hypergeometric( 20, 10, 7 );\n","base.random.improvedZiggurat":"var r = base.random.improvedZiggurat();\n","base.random.invgamma":"var r = base.random.invgamma( 2.0, 5.0 );\n","base.random.kumaraswamy":"var r = base.random.kumaraswamy( 2.0, 5.0 );\n","base.random.laplace":"var r = base.random.laplace( 2.0, 5.0 );\n","base.random.levy":"var r = base.random.levy( 2.0, 5.0 );\n","base.random.logistic":"var r = base.random.logistic( 2.0, 5.0 );\n","base.random.lognormal":"var r = base.random.lognormal( 2.0, 5.0 );\n","base.random.minstd":"var r = base.random.minstd();\n","base.random.minstdShuffle":"var r = base.random.minstdShuffle();\n","base.random.mt19937":"var r = base.random.mt19937();\n","base.random.negativeBinomial":"var r = base.random.negativeBinomial( 20, 0.8 );\n","base.random.normal":"var r = base.random.normal( 2.0, 5.0 );\n","base.random.pareto1":"var r = base.random.pareto1( 2.0, 5.0 );\n","base.random.poisson":"var r = base.random.poisson( 7.9 );\n","base.random.randi":"var r = base.random.randi();\n","base.random.randn":"var r = base.random.randn();\n","base.random.randu":"var r = base.random.randu();\n","base.random.rayleigh":"var r = base.random.rayleigh( 2.5 );\n","base.random.t":"var r = base.random.t( 2.0 );\n","base.random.triangular":"var r = base.random.triangular( 2.0, 5.0, 3.33 );\n","base.random.uniform":"var r = base.random.uniform( 2.0, 5.0 );\n","base.random.weibull":"var r = base.random.weibull( 2.0, 5.0 );\n","base.reldiff":"var d = base.reldiff( 2.0, 5.0 )\nd = base.reldiff( -1.0, 3.14 )\nd = base.reldiff( -2.0, 5.0, 'max-abs' )\nd = base.reldiff( -2.0, 5.0, 'max' )\nd = base.reldiff( -2.0, 5.0, 'min-abs' )\nd = base.reldiff( -2.0, 5.0, 'min' )\nd = base.reldiff( -2.0, 5.0, 'mean-abs' )\nd = base.reldiff( -2.0, 5.0, 'mean' )\nd = base.reldiff( -2.0, 5.0, 'x' )\nd = base.reldiff( 5.0, -2.0, 'x' )\nd = base.reldiff( -2.0, 5.0, 'y' )\nd = base.reldiff( 5.0, -2.0, 'y' )\n\n// Custom scale function:\nfunction scale( x, y ) {\n var s;\n ...\n x = base.abs( x );\n y = base.abs( y );\n ...\n // Maximum absolute value:\n s = (x < y ) ? y : x;\n ...\n // Scale in units of epsilon:\n return s * EPS;\n};\nd = base.reldiff( 12.15, 12.149999999999999, scale )\n","base.rempio2":"var y = new Array( 2 );\nvar n = base.rempio2( 128.0, y )\nvar y1 = y[ 0 ]\nvar y2 = y[ 1 ]\n","base.risingFactorial":"var v = base.risingFactorial( 0.9, 5 )\nv = base.risingFactorial( -9.0, 3 )\nv = base.risingFactorial( 0.0, 2 )\nv = base.risingFactorial( 3.0, -2 )\n","base.rotl32":"var x = 2147483649;\nvar bStr = base.toBinaryStringUint32( x )\nvar y = base.rotl32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n","base.rotr32":"var x = 1;\nvar bStr = base.toBinaryStringUint32( x )\nvar y = base.rotr32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n","base.round":"var y = base.round( 3.14 )\ny = base.round( -4.2 )\ny = base.round( -4.6 )\ny = base.round( 9.5 )\ny = base.round( -0.0 )\n","base.round2":"var y = base.round2( 3.14 )\ny = base.round2( -4.2 )\ny = base.round2( -4.6 )\ny = base.round2( 9.5 )\ny = base.round2( 13.0 )\ny = base.round2( -13.0 )\ny = base.round2( -0.0 )\n","base.round10":"var y = base.round10( 3.14 )\ny = base.round10( -4.2 )\ny = base.round10( -4.6 )\ny = base.round10( 9.5 )\ny = base.round10( 13.0 )\ny = base.round10( -13.0 )\ny = base.round10( -0.0 )\n","base.roundb":"\n// Round to 2 decimal places:\nvar y = base.roundb( 3.14159, -2, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.roundb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two:\ny = base.roundb( 5.0, 1, 2 )\n","base.roundn":"\n// Round to 2 decimal places:\nvar y = base.roundn( 3.14159, -2 )\n\n// If `n = 0`, standard round behavior:\ny = base.roundn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.roundn( 12368.0, 3 )\n","base.roundsd":"var y = base.roundsd( 3.14159, 3 )\ny = base.roundsd( 3.14159, 1 )\ny = base.roundsd( 12368.0, 2 )\ny = base.roundsd( 0.0313, 2, 2 )\n","base.rsqrt":"var y = base.rsqrt( 4.0 )\ny = base.rsqrt( 100.0 )\ny = base.rsqrt( 0.0 )\ny = base.rsqrt( Infinity )\ny = base.rsqrt( -4.0 )\ny = base.rsqrt( NaN )\n","base.sasum":"\n// Standard usage:\nvar x = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nvar sum = base.sasum( x.length, x, 1 )\n\n// Sum every other value:\nvar N = base.floor( x.length / 2 );\nvar stride = 2;\nsum = base.sasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nvar x0 = new Float32Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.sasum( N, x1, stride )\n","base.saxpy":"\n// Standard usage:\nvar x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nvar alpha = 5.0;\nbase.saxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nvar N = base.floor( x.length / 2 );\nbase.saxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nvar x0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.saxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n","base.scopy":"\n// Standard usage:\nvar x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\nvar y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.scopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar N = base.floor( x.length / 2 );\nbase.scopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nvar x0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\nvar y0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nvar x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nvar y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.scopy( N, x1, -2, y1, 1 )\ny0\n","base.setHighWord":"\n// Set the higher order bits of `+infinity` to return `1`:\nvar high = 1072693248 >>> 0;\nvar y = base.setHighWord( PINF, high )\n","base.setLowWord":"var low = 5 >>> 0;\nvar x = 3.14e201;\nvar y = base.setLowWord( x, low )\n\n// Special cases:\nvar low = 12345678;\nvar y = base.setLowWord( PINF, low )\ny = base.setLowWord( NINF, low )\ny = base.setLowWord( NaN, low )\n","base.sici":"var y = base.sici( 3.0 )\ny = base.sici( 0.0 )\ny = base.sici( -9.0 )\ny = base.sici( NaN )\n\n// Provide an output array:\nvar out = new Float64Array( 2 );\ny = base.sici( out, 3.0 )\nvar bool = ( y === out )\n","base.signbit":"var bool = base.signbit( 4.0 )\nbool = base.signbit( -9.14e-34 )\nbool = base.signbit( 0.0 )\nbool = base.signbit( -0.0 )\n","base.signbitf":"var bool = base.signbitf( base.float64ToFloat32( 4.0 ) )\nbool = base.signbitf( base.float64ToFloat32( -9.14e-34 ) )\nbool = base.signbitf( 0.0 )\nbool = base.signbitf( -0.0 )\n","base.significandf":"var s = base.significandf( base.float64ToFloat32( 3.14e34 ) )\ns = base.significandf( base.float64ToFloat32( 3.14e-34 ) )\ns = base.significandf( base.float64ToFloat32( -3.14 ) )\ns = base.significandf( 0.0 )\ns = base.significandf( NaN )\n","base.signum":"var sign = base.signum( -5.0 )\nsign = base.signum( 5.0 )\nsign = base.signum( -0.0 )\nsign = base.signum( 0.0 )\nsign = base.signum( NaN )\n","base.sin":"var y = base.sin( 0.0 )\ny = base.sin( PI/2.0 )\ny = base.sin( -PI/6.0 )\ny = base.sin( NaN )\n","base.sinc":"var y = base.sinc( 0.5 )\ny = base.sinc( -1.2 )\ny = base.sinc( 0.0 )\ny = base.sinc( NaN )\n","base.sincos":"var y = base.sincos( 0.0 )\ny = base.sincos( PI/2.0 )\ny = base.sincos( -PI/6.0 )\ny = base.sincos( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.sincos( out, 0.0 )\nvar bool = ( v === out )\n","base.sincospi":"var y = base.sincospi( 0.0 )\ny = base.sincospi( 0.5 )\ny = base.sincospi( 0.1 )\ny = base.sincospi( NaN )\nvar out = new Float64Array( 2 );\nvar v = base.sincospi( out, 0.0 )\nvar bool = ( v === out )\n","base.sinh":"var y = base.sinh( 0.0 )\ny = base.sinh( 2.0 )\ny = base.sinh( -2.0 )\ny = base.sinh( NaN )\n","base.sinpi":"var y = base.sinpi( 0.0 )\ny = base.sinpi( 0.5 )\ny = base.sinpi( 0.9 )\ny = base.sinpi( NaN )\n","base.spence":"var y = base.spence( 3.0 )\ny = base.spence( 0.0 )\ny = base.spence( -9.0 )\ny = base.spence( NaN )\n","base.sqrt":"var y = base.sqrt( 4.0 )\ny = base.sqrt( 9.0 )\ny = base.sqrt( 0.0 )\ny = base.sqrt( -4.0 )\ny = base.sqrt( NaN )\n","base.sqrt1pm1":"var y = base.sqrt1pm1( 3.0 )\ny = base.sqrt1pm1( 0.5 )\ny = base.sqrt1pm1( 0.02 )\ny = base.sqrt1pm1( -0.5 )\ny = base.sqrt1pm1( -1.1 )\ny = base.sqrt1pm1( NaN )\n","base.sumSeries":"\n// Using an ES6 generator function:\nfunction* geometricSeriesGenerator( x ) {\n var exponent = 0;\n while ( true ) {\n yield Math.pow( x, exponent );\n exponent += 1;\n }\n};\nvar gen = geometricSeriesGenerator( 0.9 );\nvar out = base.sumSeries( gen )\n\n// Using a closure:\nfunction geometricSeriesClosure( x ) {\n var exponent = -1;\n return function() {\n exponent += 1;\n return Math.pow( x, exponent );\n };\n};\ngen = geometricSeriesClosure( 0.9 );\nout = base.sumSeries( gen )\n\n// Setting an initial value for the sum:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'initialValue': 1 } )\n\n// Changing the maximum number of terms to be summed:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'maxTerms': 10 } )\n\n// Adjusting the used tolerance:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'tolerance': 1e-3 } )\n","base.tan":"var y = base.tan( 0.0 )\ny = base.tan( -PI/4.0 )\ny = base.tan( PI/4.0 )\ny = base.tan( NaN )\n","base.tanh":"var y = base.tanh( 0.0 )\nvar y = base.tanh( -0.0 )\ny = base.tanh( 2.0 )\ny = base.tanh( -2.0 )\ny = base.tanh( NaN )\n","base.toBinaryString":"var str = base.toBinaryString( 4.0 )\nstr = base.toBinaryString( PI )\nstr = base.toBinaryString( -1.0e308 )\nstr = base.toBinaryString( -3.14e-320 )\nstr = base.toBinaryString( 5.0e-324 )\nstr = base.toBinaryString( 0.0 )\nstr = base.toBinaryString( -0.0 )\nstr = base.toBinaryString( NaN )\nstr = base.toBinaryString( PINF )\nstr = base.toBinaryString( NINF )\n","base.toBinaryStringf":"var str = base.toBinaryStringf( base.float64ToFloat32( 4.0 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( PI ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -1.0e38 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -3.14e-39 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( 1.4e-45 ) )\nstr = base.toBinaryStringf( 0.0 )\nstr = base.toBinaryStringf( -0.0 )\nstr = base.toBinaryStringf( NaN )\nstr = base.toBinaryStringf( FLOAT32_PINF )\nstr = base.toBinaryStringf( FLOAT32_NINF )\n","base.toBinaryStringUint8":"var a = new Uint8Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint8( a[ 0 ] )\nstr = base.toBinaryStringUint8( a[ 1 ] )\nstr = base.toBinaryStringUint8( a[ 2 ] )\n","base.toBinaryStringUint16":"var a = new Uint16Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint16( a[ 0 ] )\nstr = base.toBinaryStringUint16( a[ 1 ] )\nstr = base.toBinaryStringUint16( a[ 2 ] )\n","base.toBinaryStringUint32":"var a = new Uint32Array( [ 1, 4, 9 ] );\nvar str = base.toBinaryStringUint32( a[ 0 ] )\nstr = base.toBinaryStringUint32( a[ 1 ] )\nstr = base.toBinaryStringUint32( a[ 2 ] )\n","base.toWordf":"var f32 = base.float64ToFloat32( 1.337 )\nvar w = base.toWordf( f32 )\n","base.toWords":"var w = base.toWords( 3.14e201 )\n\n// Provide an output array:\nvar out = new Uint32Array( 2 );\nw = base.toWords( out, 3.14e201 )\nvar bool = ( w === out )\n","base.trigamma":"var y = base.trigamma( -2.5 )\ny = base.trigamma( 1.0 )\ny = base.trigamma( 10.0 )\ny = base.trigamma( NaN )\ny = base.trigamma( -1.0 )\n","base.trunc":"var y = base.trunc( 3.14 )\ny = base.trunc( -4.2 )\ny = base.trunc( -4.6 )\ny = base.trunc( 9.5 )\ny = base.trunc( -0.0 )\n","base.trunc2":"var y = base.trunc2( 3.14 )\ny = base.trunc2( -4.2 )\ny = base.trunc2( -4.6 )\ny = base.trunc2( 9.5 )\ny = base.trunc2( 13.0 )\ny = base.trunc2( -13.0 )\ny = base.trunc2( -0.0 )\n","base.trunc10":"var y = base.trunc10( 3.14 )\ny = base.trunc10( -4.2 )\ny = base.trunc10( -4.6 )\ny = base.trunc10( 9.5 )\ny = base.trunc10( 13.0 )\ny = base.trunc10( -13.0 )\ny = base.trunc10( -0.0 )\n","base.truncb":"\n// Round to 4 decimal places:\nvar y = base.truncb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.truncb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward zero:\ny = base.truncb( 5.0, 1, 2 )\n","base.truncn":"\n// Round to 4 decimal places:\nvar y = base.truncn( 3.14159, -4 )\n\n// If `n = 0`, standard round behavior:\ny = base.truncn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.truncn( 12368.0, 3 )\n","base.truncsd":"var y = base.truncsd( 3.14159, 5 )\ny = base.truncsd( 3.14159, 1 )\ny = base.truncsd( 12368.0, 2 )\ny = base.truncsd( 0.0313, 2, 2 )\n","base.uimul":"var v = base.uimul( 10>>>0, 4>>>0 )\n","base.uimuldw":"var v = base.uimuldw( 1, 10 )\n","base.uint32ToInt32":"var y = base.uint32ToInt32( base.float64ToUint32( 4294967295 ) )\ny = base.uint32ToInt32( base.float64ToUint32( 3 ) )\n","base.vercos":"var y = base.vercos( 3.14 )\ny = base.vercos( -4.2 )\ny = base.vercos( -4.6 )\ny = base.vercos( 9.5 )\ny = base.vercos( -0.0 )\n","base.versin":"var y = base.versin( 3.14 )\ny = base.versin( -4.2 )\ny = base.versin( -4.6 )\ny = base.versin( 9.5 )\ny = base.versin( -0.0 )\n","base.wrap":"var y = base.wrap( 3.14, 0.0, 5.0 )\ny = base.wrap( -3.14, 0.0, 5.0 )\ny = base.wrap( 3.14, 0.0, 3.0 )\ny = base.wrap( -0.0, 0.0, 5.0 )\ny = base.wrap( 0.0, -3.14, -0.0 )\ny = base.wrap( NaN, 0.0, 5.0 )\n","base.xlog1py":"var out = base.xlog1py( 3.0, 2.0 )\nout = base.xlog1py( 1.5, 5.9 )\nout = base.xlog1py( 0.9, 1.0 )\nout = base.xlog1py( 1.0, 0.0 )\nout = base.xlog1py( 0.0, -2.0 )\nout = base.xlog1py( 1.5, NaN )\nout = base.xlog1py( 0.0, NaN )\nout = base.xlog1py( NaN, 2.3 )\n","base.xlogy":"var out = base.xlogy( 3.0, 2.0 )\nout = base.xlogy( 1.5, 5.9 )\nout = base.xlogy( 0.9, 1.0 )\nout = base.xlogy( 0.0, -2.0 )\nout = base.xlogy( 1.5, NaN )\nout = base.xlogy( 0.0, NaN )\nout = base.xlogy( NaN, 2.3 )\n","base.zeta":"var y = base.zeta( 1.1 )\ny = base.zeta( -4.0 )\ny = base.zeta( 70.0 )\ny = base.zeta( 0.5 )\ny = base.zeta( NaN )\n\n// Evaluate at a pole:\ny = base.zeta( 1.0 )\n","BERNDT_CPS_WAGES_1985":"var data = BERNDT_CPS_WAGES_1985()\n","bifurcate":"var collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar f = [ true, true, false, true ];\nvar out = bifurcate( collection, f )\nf = [ 1, 1, 0, 1 ];\nout = bifurcate( collection, f )\n\n// Output group results as indices:\nf = [ true, true, false, true ];\nvar opts = { 'returns': 'indices' };\nout = bifurcate( collection, opts, f )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = bifurcate( collection, opts, f )\n","bifurcateBy":"function predicate( v ) { return v[ 0 ] === 'b'; };\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = bifurcateBy( collection, predicate )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nout = bifurcateBy( collection, opts, predicate )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateBy( collection, opts, predicate )\n","bifurcateByAsync":"\n// Basic usage:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, predicate, done )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n","bifurcateIn":"function Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nvar obj = new Foo();\nfunction predicate( v ) { return v[ 0 ] === 'b'; };\nvar out = bifurcateIn( obj, predicate )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = bifurcateIn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateIn( obj, opts, predicate )\n","bifurcateOwn":"function predicate( v ) { return v[ 0 ] === 'b'; };\nvar obj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nvar out = bifurcateOwn( obj, predicate )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = bifurcateOwn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateOwn( obj, opts, predicate )\n","binomialTest":"var out = binomialTest( 682, 925 )\nout = binomialTest( [ 682, 925 - 682 ] )\nout = binomialTest( 21, 40, {\n 'p': 0.4,\n 'alternative': 'greater'\n})\n","Buffer":"var b = new Buffer( 4 )\n","buffer2json":"var buf = new allocUnsafe( 2 );\nbuf[ 0 ] = 1;\nbuf[ 1 ] = 2;\nvar json = buffer2json( buf )\n","capitalize":"var out = capitalize( 'beep' )\nout = capitalize( 'Boop' )\n","capitalizeKeys":"var obj = { 'aa': 1, 'bb': 2 };\nvar out = capitalizeKeys( obj )\n","CATALAN":"CATALAN\n","CBRT_EPS":"CBRT_EPS\n","chdir":"var err = chdir( '/path/to/current/working/directory' )\n","chi2gof":"\n// Provide expected probabilities...\nvar x = [ 89, 37, 30, 28, 2 ];\nvar p = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nvar out = chi2gof( x, p )\nout.print()\n\n// Set significance level...\nvar opts = { 'alpha': 0.01 };\nout = chi2gof( x, p, opts );\nout.print()\n\n// Calculate the test p-value via Monte Carlo simulation...\nx = [ 89, 37, 30, 28, 2 ];\np = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nopts = { 'simulate': true, 'iterations': 1000 };\nout = chi2gof( x, p, opts )\n\n// Verify that data comes from Poisson distribution...\nvar lambda = 3.0;\nvar rpois = base.random.poisson.factory( lambda );\nvar len = 400;\nx = [];\nfor ( var i = 0; i < len; i++ ) { x.push( rpois() ); };\n\n// Generate a frequency table...\nvar freqs = new Int32Array( len );\nfor ( i = 0; i < len; i++ ) { freqs[ x[ i ] ] += 1; };\nout = chi2gof( freqs, 'poisson', lambda )\n","circarray2iterator":"var it = circarray2iterator( [ 1, 2, 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n","circularArrayStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 15 };\nvar s = circularArrayStream( [ 1, 2, 3 ], opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","CircularBuffer":"var b = CircularBuffer( 3 );\nb.push( 'foo' );\nb.push( 'bar' );\nb.push( 'beep' );\nb.length\nb.count\nb.push( 'boop' )\n","CMUDICT":"var data = CMUDICT();\nvar dict = data.dict\nvar phones = data.phones\nvar symbols = data.symbols\nvar vp = data.vp\n","complex":"var z = complex( 5.0, 3.0, 'float64' )\nz = complex( 5.0, 3.0, 'float32' )\n","Complex64":"var z = new Complex64( 5.0, 3.0 )\nz.re\nz.im\n","COMPLEX64_NUM_BYTES":"COMPLEX64_NUM_BYTES\n","Complex128":"var z = new Complex128( 5.0, 3.0 )\nz.re\nz.im\n","COMPLEX128_NUM_BYTES":"COMPLEX128_NUM_BYTES\n","compose":"function a( x ) {\n return 2 * x;\n}\nfunction b( x ) {\n return x + 3;\n}\nfunction c( x ) {\n return x / 5;\n}\nvar f = compose( c, b, a );\nvar z = f( 6 )\n","composeAsync":"function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nvar f = composeAsync( c, b, a );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n","configdir":"var dir = configdir()\ndir = configdir( 'appname/config' )\n","conj":"var z = new Complex128( 5.0, 3.0 );\nz.toString()\nvar v = conj( z );\nv.toString()\n","constantFunction":"var fcn = constantFunction( 3.14 );\nvar v = fcn()\nv = fcn()\nv = fcn()\n","constantStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = constantStream( 'beep', opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","constructorName":"var v = constructorName( 'a' )\nv = constructorName( {} )\nv = constructorName( true )\n","contains":"var bool = contains( 'Hello World', 'World' )\nbool = contains( 'Hello World', 'world' )\nbool = contains( [ 1, 2, 3, 4 ], 2 )\nbool = contains( [ NaN, 2, 3, 4 ], NaN )\n\n// Supply a position:\nbool = contains( 'Hello World', 'Hello', 6 )\nbool = contains( [ true, NaN, false ], true, 1 )\n","convertArray":"var arr = [ 1.0, 2.0, 3.0, 4.0 ];\nvar out = convertArray( arr, 'float32' )\n","convertArraySame":"var x = [ 1.0, 2.0, 3.0, 4.0 ];\nvar y = new Float32Array( 0 );\nvar out = convertArraySame( x, y )\n","convertPath":"var out = convertPath( '/c/foo/bar/beep.c', 'win32' )\nout = convertPath( '/c/foo/bar/beep.c', 'mixed' )\nout = convertPath( '/c/foo/bar/beep.c', 'posix' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'win32' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'mixed' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'posix' )\n","copy":"var value = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nvar out = copy( value )\nvar bool = ( value[ 0 ].c === out[ 0 ].c )\n\n// Set the `level` option to limit the copy depth:\nvalue = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nout = copy( value, 1 );\nbool = ( value[ 0 ] === out[ 0 ] )\nbool = ( value[ 0 ].c === out[ 0 ].c )\n","copyBuffer":"var b1 = array2buffer( [ 1, 2, 3, 4 ] );\nvar b2 = copyBuffer( b1 )\n","countBy":"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = countBy( collection, indicator )\n","countByAsync":"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n","curry":"function add( x, y ) { return x + y; };\nvar f = curry( add );\nvar sum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curry( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nvar obj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curry( obj.greet, obj );\nvar str = f( 'Hello' )( 'there' )\n","curryRight":"function add( x, y ) { return x + y; };\nvar f = curryRight( add );\nvar sum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curryRight( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nvar obj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curryRight( obj.greet, obj );\nvar str = f( 'there' )( 'Hello' )\n","cwd":"var dir = cwd()\n","DALE_CHALL_NEW":"var list = DALE_CHALL_NEW()\n","datasets":"var out = datasets( 'MONTH_NAMES_EN' )\nvar opts = { 'data': 'cities' };\nout = datasets( 'MINARD_NAPOLEONS_MARCH', opts )\n","dayOfQuarter":"var day = dayOfQuarter()\nday = dayOfQuarter( new Date() )\nday = dayOfQuarter( 12, 31, 2017 )\n\n// Other ways to supply month:\nday = dayOfQuarter( 'dec', 31, 2017 )\nday = dayOfQuarter( 'december', 31, 2017 )\n","dayOfYear":"var day = dayOfYear()\nday = dayOfYear( new Date() )\nday = dayOfYear( 12, 31, 2016 )\n\n// Other ways to supply month:\nday = dayOfYear( 'dec', 31, 2016 )\nday = dayOfYear( 'december', 31, 2016 )\n","daysInMonth":"var num = daysInMonth()\nnum = daysInMonth( 2 )\nnum = daysInMonth( 2, 2016 )\nnum = daysInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = daysInMonth( 'feb', 2016 )\nnum = daysInMonth( 'february', 2016 )\n","daysInYear":"var num = daysInYear()\nnum = daysInYear( 2016 )\nnum = daysInYear( 2017 )\n","debugSinkStream":"var s = debugSinkStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","debugStream":"var s = debugStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","deepEqual":"var bool = deepEqual( [ 1, 2, 3 ], [ 1, 2, 3 ] )\nbool = deepEqual( [ 1, 2, 3 ], [ 1, 2, '3' ] )\nbool = deepEqual( { 'a': 2 }, { 'a': [ 2 ] } )\n","deepGet":"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar val = deepGet( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nvar obj = { 'a': { 'b': { 'c': 'd' } } };\nvar val = deepGet( obj, 'a/b/c', { 'sep': '/' } )\n","deepHasOwnProp":"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar bool = deepHasOwnProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepHasOwnProp( obj, 'a/b/c', { 'sep': '/' } )\n","deepHasProp":"function Foo() { return this; };\nFoo.prototype.b = { 'c': 'd' };\nvar obj = { 'a': new Foo() };\nvar bool = deepHasProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nbool = deepHasProp( obj, 'a/b/c', { 'sep': '/' } )\n","deepPluck":"var arr = [\n { 'a': { 'b': { 'c': 1 } } },\n { 'a': { 'b': { 'c': 2 } } }\n];\nvar out = deepPluck( arr, 'a.b.c' )\narr = [\n { 'a': [ 0, 1, 2 ] },\n { 'a': [ 3, 4, 5 ] }\n];\nout = deepPluck( arr, [ 'a', 1 ] )\n","deepSet":"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar bool = deepSet( obj, 'a.b.c', 'beep' )\n\n// Specify an alternative separator via the sep option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepSet( obj, 'a/b/c', 'beep', { 'sep': '/' } );\nobj\n\n// To create a key path which does not exist, set the create option to true:\nbool = deepSet( obj, 'a.e.c', 'boop', { 'create': true } );\nobj\n","defineMemoizedProperty":"var obj = {};\nfunction foo() {\n return 'bar';\n};\ndefineMemoizedProperty( obj, 'foo', {\n 'configurable': false,\n 'enumerable': true,\n 'writable': false,\n 'value': foo\n});\nobj.foo\n","defineProperties":"var obj = {};\ndefineProperties( obj, {\n 'foo': {\n 'value': 'bar',\n 'writable': false,\n 'configurable': false,\n 'enumerable': true\n },\n 'baz': {\n 'value': 13\n }\n});\nobj.foo\nobj.baz\n","defineProperty":"var obj = {};\ndefineProperty( obj, 'foo', {\n 'value': 'bar',\n 'enumerable': true,\n 'writable': false\n});\nobj.foo = 'boop';\nobj\n","dirname":"var dir = dirname( './foo/bar/index.js' )\n","DoublyLinkedList":"var list = DoublyLinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n","doUntil":"function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoUntil( beep, predicate )\n","doUntilAsync":"function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoUntilAsync( fcn, predicate, done )\n","doUntilEach":"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\ndoUntilEach( arr, logger, predicate )\n","doUntilEachRight":"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\ndoUntilEachRight( arr, logger, predicate )\n","doWhile":"function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoWhile( beep, predicate )\n","doWhileAsync":"function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoWhileAsync( fcn, predicate, done )\n","doWhileEach":"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\ndoWhileEach( arr, logger, predicate )\n","doWhileEachRight":"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\ndoWhileEachRight( arr, logger, predicate )\n","E":"E\n","emptyStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = emptyStream();\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","endsWith":"var bool = endsWith( 'beep', 'ep' )\nbool = endsWith( 'Beep', 'op' )\nbool = endsWith( 'Beep', 'ee', 3 )\nbool = endsWith( 'Beep', 'ee', -1 )\nbool = endsWith( 'beep', '' )\n","enumerableProperties":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = enumerableProperties( obj )\n","enumerablePropertiesIn":"var props = enumerablePropertiesIn( [] )\n","enumerablePropertySymbols":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = enumerablePropertySymbols( obj )\n","enumerablePropertySymbolsIn":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = enumerablePropertySymbolsIn( obj )\n","ENV":"var user = ENV.USER\n","EPS":"EPS\n","error2json":"var err = new Error( 'beep' );\nvar json = error2json( err )\n","EULERGAMMA":"EULERGAMMA\n","every":"var arr = [ 1, 1, 1, 1, 1 ];\nvar bool = every( arr )\n","everyBy":"function positive( v ) { return ( v > 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = everyBy( arr, positive )\n","everyByAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n","everyByRight":"function positive( v ) { return ( v > 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = everyByRight( arr, positive )\n","everyByRightAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n","evil":"var v = evil( '5*4*3*2*1' )\n","exists":"function done( error, bool ) { console.log( bool ); };\nexists( './beep/boop', done );\n","expandContractions":"var str = 'I won\\'t be able to get y\\'all out of this one.';\nvar out = expandContractions( str )\nstr = 'It oughtn\\'t to be my fault, because, you know, I didn\\'t know';\nout = expandContractions( str )\n","extname":"var ext = extname( 'index.js' )\n","fastmath.abs":"var v = fastmath.abs( -1.0 )\nv = fastmath.abs( 2.0 )\nv = fastmath.abs( 0.0 )\nv = fastmath.abs( -0.0 )\nv = fastmath.abs( NaN )\n","fastmath.acosh":"var v = fastmath.acosh( 1.0 )\nv = fastmath.acosh( 2.0 )\nv = fastmath.acosh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.acosh( 1.0e308 )\n","fastmath.ampbm":"var h = fastmath.ampbm( 5.0, 12.0 )\n","fastmath.asinh":"var v = fastmath.asinh( 0.0 )\nv = fastmath.asinh( 2.0 )\nv = fastmath.asinh( -2.0 )\nv = fastmath.asinh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.asinh( 1.0e200 )\n\n// The function underflows for small `x`:\nv = fastmath.asinh( 1.0e-50 )\n","fastmath.atanh":"var v = fastmath.atanh( 0.0 )\nv = fastmath.atanh( 0.9 )\nv = fastmath.atanh( 1.0 )\nv = fastmath.atanh( -1.0 )\nv = fastmath.atanh( NaN )\n\n// The function underflows for small `x`:\nv = fastmath.atanh( 1.0e-17 )\n","fastmath.hypot":"var h = fastmath.hypot( -5.0, 12.0 )\n\n// For a sufficiently large `x` and/or `y`, the function overflows:\nh = fastmath.hypot( 1.0e154, 1.0e154 )\n\n// For sufficiently small `x` and/or `y`, the function underflows:\nh = fastmath.hypot( 1e-200, 1.0e-200 )\n","fastmath.log2Uint32":"var v = fastmath.log2Uint32( 4 >>> 0 )\nv = fastmath.log2Uint32( 8 >>> 0 )\nv = fastmath.log2Uint32( 9 >>> 0 )\n","fastmath.max":"var v = fastmath.max( 3.14, 4.2 )\nv = fastmath.max( 3.14, NaN )\nv = fastmath.max( NaN, 3.14 )\nv = fastmath.max( -0.0, +0.0 )\nv = fastmath.max( +0.0, -0.0 )\n","fastmath.min":"var v = fastmath.min( 3.14, 4.2 )\nv = fastmath.min( 3.14, NaN )\nv = fastmath.min( NaN, 3.14 )\nv = fastmath.min( -0.0, +0.0 )\nv = fastmath.min( +0.0, -0.0 )\n","fastmath.powint":"var v = fastmath.powint( 2.0, 3 )\nv = fastmath.powint( 3.14, 0 )\nv = fastmath.powint( 2.0, -2 )\nv = fastmath.powint( 0.0, 0 )\nv = fastmath.powint( -3.14, 1 )\nv = fastmath.powint( NaN, 0 )\n","fastmath.sqrtUint32":"var v = fastmath.sqrtUint32( 9 >>> 0 )\nv = fastmath.sqrtUint32( 2 >>> 0 )\nv = fastmath.sqrtUint32( 3 >>> 0 )\nv = fastmath.sqrtUint32( 0 >>> 0 )\n","FEMALE_FIRST_NAMES_EN":"var list = FEMALE_FIRST_NAMES_EN()\n","FIFO":"var q = FIFO();\nq.push( 'foo' ).push( 'bar' );\nq.length\nq.pop()\nq.length\nq.pop()\nq.length\n","find":"var data = [ 30, 20, 50, 60, 10 ];\nfunction condition( val ) { return val > 20; };\nvar vals = find( data, condition )\n\n// Limit number of results:\ndata = [ 30, 20, 50, 60, 10 ];\nvar opts = { 'k': 2, 'returns': 'values' };\nvals = find( data, opts, condition )\n\n// Return both indices and values as index-value pairs:\ndata = [ 30, 20, 50, 60, 10 ];\nopts = { 'k': -2, 'returns': '*' };\nvals = find( data, opts, condition )\n","flattenArray":"var arr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nvar out = flattenArray( arr )\n\n// Set the maximum depth:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2 } )\nvar bool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n\n// Deep copy:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2, 'copy': true } )\nbool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n","flattenObject":"var obj = { 'a': { 'b': { 'c': 'd' } } };\nvar out = flattenObject( obj )\n\n// Set the `depth` option to flatten to a specified depth:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'depth': 1 } )\nvar bool = ( obj.a.b === out[ 'a.b' ] )\n\n// Set the `delimiter` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'delimiter': '-|-' } )\n\n// Flatten arrays:\nobj = { 'a': { 'b': [ 1, 2, 3 ] } };\nout = flattenObject( obj, { 'flattenArrays': true } )\n","flignerTest":"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = flignerTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = flignerTest( arr, { 'groups': groups })\n","FLOAT16_CBRT_EPS":"FLOAT16_CBRT_EPS\n","FLOAT16_EPS":"FLOAT16_EPS\n","FLOAT16_EXPONENT_BIAS":"FLOAT16_EXPONENT_BIAS\n","FLOAT16_MAX":"FLOAT16_MAX\n","FLOAT16_MAX_SAFE_INTEGER":"FLOAT16_MAX_SAFE_INTEGER\n","FLOAT16_MIN_SAFE_INTEGER":"FLOAT16_MIN_SAFE_INTEGER\n","FLOAT16_NINF":"FLOAT16_NINF\n","FLOAT16_NUM_BYTES":"FLOAT16_NUM_BYTES\n","FLOAT16_PINF":"FLOAT16_PINF\n","FLOAT16_PRECISION":"FLOAT16_PRECISION\n","FLOAT16_SMALLEST_NORMAL":"FLOAT16_SMALLEST_NORMAL\n","FLOAT16_SMALLEST_SUBNORMAL":"FLOAT16_SMALLEST_SUBNORMAL\n","FLOAT16_SQRT_EPS":"FLOAT16_SQRT_EPS\n","FLOAT32_CBRT_EPS":"FLOAT32_CBRT_EPS\n","FLOAT32_EPS":"FLOAT32_EPS\n","FLOAT32_EXPONENT_BIAS":"FLOAT32_EXPONENT_BIAS\n","FLOAT32_MAX":"FLOAT32_MAX\n","FLOAT32_MAX_SAFE_INTEGER":"FLOAT32_MAX_SAFE_INTEGER\n","FLOAT32_MIN_SAFE_INTEGER":"FLOAT32_MIN_SAFE_INTEGER\n","FLOAT32_NINF":"FLOAT32_NINF\n","FLOAT32_NUM_BYTES":"FLOAT32_NUM_BYTES\n","FLOAT32_PINF":"FLOAT32_PINF\n","FLOAT32_PRECISION":"FLOAT32_PRECISION\n","FLOAT32_SMALLEST_NORMAL":"FLOAT32_SMALLEST_NORMAL\n","FLOAT32_SMALLEST_SUBNORMAL":"FLOAT32_SMALLEST_SUBNORMAL\n","FLOAT32_SQRT_EPS":"FLOAT32_SQRT_EPS\n","Float32Array":"var arr = new Float32Array()\n","FLOAT64_EXPONENT_BIAS":"FLOAT64_EXPONENT_BIAS\n","FLOAT64_HIGH_WORD_EXPONENT_MASK":"FLOAT64_HIGH_WORD_EXPONENT_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_EXPONENT_MASK )\n","FLOAT64_HIGH_WORD_SIGNIFICAND_MASK":"FLOAT64_HIGH_WORD_SIGNIFICAND_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_SIGNIFICAND_MASK )\n","FLOAT64_MAX":"FLOAT64_MAX\n","FLOAT64_MAX_BASE2_EXPONENT":"FLOAT64_MAX_BASE2_EXPONENT\n","FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL":"FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL\n","FLOAT64_MAX_BASE10_EXPONENT":"FLOAT64_MAX_BASE10_EXPONENT\n","FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL":"FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL\n","FLOAT64_MAX_LN":"FLOAT64_MAX_LN\n","FLOAT64_MAX_SAFE_FIBONACCI":"FLOAT64_MAX_SAFE_FIBONACCI\n","FLOAT64_MAX_SAFE_INTEGER":"FLOAT64_MAX_SAFE_INTEGER\n","FLOAT64_MAX_SAFE_LUCAS":"FLOAT64_MAX_SAFE_LUCAS\n","FLOAT64_MAX_SAFE_NTH_FIBONACCI":"FLOAT64_MAX_SAFE_NTH_FIBONACCI\n","FLOAT64_MAX_SAFE_NTH_LUCAS":"FLOAT64_MAX_SAFE_NTH_LUCAS\n","FLOAT64_MIN_BASE2_EXPONENT":"FLOAT64_MIN_BASE2_EXPONENT\n","FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL":"FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL\n","FLOAT64_MIN_BASE10_EXPONENT":"FLOAT64_MIN_BASE10_EXPONENT\n","FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL":"FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL\n","FLOAT64_MIN_LN":"FLOAT64_MIN_LN\n","FLOAT64_MIN_SAFE_INTEGER":"FLOAT64_MIN_SAFE_INTEGER\n","FLOAT64_NUM_BYTES":"FLOAT64_NUM_BYTES\n","FLOAT64_PRECISION":"FLOAT64_PRECISION\n","FLOAT64_SMALLEST_NORMAL":"FLOAT64_SMALLEST_NORMAL\n","FLOAT64_SMALLEST_SUBNORMAL":"FLOAT64_SMALLEST_SUBNORMAL\n","Float64Array":"var arr = new Float64Array()\n","forEach":"function logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4 ];\nforEach( arr, logger )\n","forEachAsync":"\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n","forEachRight":"function logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4 ];\nforEachRight( arr, logger )\n","forEachRightAsync":"\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n","forIn":"function logger( v, k ) { console.log( '%s: %d', k, v ); };\nfunction Foo() { return this; };\nFoo.prototype.beep = 'boop';\nvar obj = new Foo();\nforIn( obj, logger )\n","forOwn":"function logger( v, k ) { console.log( '%s: %d', k, v ); };\nvar obj = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 };\nforOwn( obj, logger )\n","FOURTH_PI":"FOURTH_PI\n","FOURTH_ROOT_EPS":"FOURTH_ROOT_EPS\n","FRB_SF_WAGE_RIGIDITY":"var data = FRB_SF_WAGE_RIGIDITY()\n","fromCodePoint":"var out = fromCodePoint( 9731 )\nout = fromCodePoint( [ 9731 ] )\nout = fromCodePoint( 97, 98, 99 )\nout = fromCodePoint( [ 97, 98, 99 ] )\n","functionName":"var v = functionName( String )\nv = functionName( function foo(){} )\nv = functionName( function(){} )\n","functionSequence":"function a( x ) { return 2 * x; };\nfunction b( x ) { return x + 3; };\nfunction c( x ) { return x / 5; };\nvar f = functionSequence( a, b, c );\nvar z = f( 6 )\n","functionSequenceAsync":"function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nvar f = functionSequenceAsync( a, b, c );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n","GAMMA_LANCZOS_G":"GAMMA_LANCZOS_G\n","getegid":"var gid = getegid()\n","geteuid":"var uid = geteuid()\n","getgid":"var gid = getgid()\n","getGlobal":"var g = getGlobal()\n","getPrototypeOf":"var proto = getPrototypeOf( {} )\n","getuid":"var uid = getuid()\n","GLAISHER":"GLAISHER\n","group":"var collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar groups = [ 'b', 'b', 'f', 'b' ];\nvar out = group( collection, groups )\ngroups = [ 1, 1, 2, 1 ];\nout = group( collection, groups )\n\n// Output group results as indices:\ngroups = [ 'b', 'b', 'f', 'b' ];\nvar opts = { 'returns': 'indices' };\nout = group( collection, opts, groups )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = group( collection, opts, groups )\n","groupBy":"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar collection = [ 'beep', 'boop', 'foo', 'bar' ];\nvar out = groupBy( collection, indicator )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\nout = groupBy( collection, opts, indicator )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = groupBy( collection, opts, indicator )\n","groupByAsync":"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, indicator, done )\n\n// Output group results as indices:\nvar opts = { 'returns': 'indices' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n","groupIn":"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nfunction Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nvar obj = new Foo();\nvar out = groupIn( obj, indicator )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = groupIn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupIn( obj, opts, indicator )\n","groupOwn":"function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nvar obj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nvar out = groupOwn( obj, indicator )\n\n// Output group results as keys:\nvar opts = { 'returns': 'keys' };\nout = groupOwn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupOwn( obj, opts, indicator )\n","HALF_LN2":"HALF_LN2\n","HALF_PI":"HALF_PI\n","HARRISON_BOSTON_HOUSE_PRICES":"var data = HARRISON_BOSTON_HOUSE_PRICES()\n","HARRISON_BOSTON_HOUSE_PRICES_CORRECTED":"var data = HARRISON_BOSTON_HOUSE_PRICES_CORRECTED()\n","hasArrayBufferSupport":"var bool = hasArrayBufferSupport()\n","hasAsyncAwaitSupport":"var bool = hasAsyncAwaitSupport()\n","hasAsyncIteratorSymbolSupport":"var bool = hasAsyncIteratorSymbolSupport()\n","hasClassSupport":"var bool = hasClassSupport()\n","hasDefinePropertiesSupport":"var bool = hasDefinePropertiesSupport()\n","hasDefinePropertySupport":"var bool = hasDefinePropertySupport()\n","hasFloat32ArraySupport":"var bool = hasFloat32ArraySupport()\n","hasFloat64ArraySupport":"var bool = hasFloat64ArraySupport()\n","hasFunctionNameSupport":"var bool = hasFunctionNameSupport()\n","hasGeneratorSupport":"var bool = hasGeneratorSupport()\n","hasInt8ArraySupport":"var bool = hasInt8ArraySupport()\n","hasInt16ArraySupport":"var bool = hasInt16ArraySupport()\n","hasInt32ArraySupport":"var bool = hasInt32ArraySupport()\n","hasIteratorSymbolSupport":"var bool = hasIteratorSymbolSupport()\n","hasMapSupport":"var bool = hasMapSupport()\n","hasNodeBufferSupport":"var bool = hasNodeBufferSupport()\n","hasOwnProp":"var beep = { 'boop': true };\nvar bool = hasOwnProp( beep, 'boop' )\nbool = hasOwnProp( beep, 'bop' )\n","hasProp":"var beep = { 'boop': true };\nvar bool = hasProp( beep, 'boop' )\nbool = hasProp( beep, 'toString' )\nbool = hasProp( beep, 'bop' )\n","hasProxySupport":"var bool = hasProxySupport()\n","hasSetSupport":"var bool = hasSetSupport()\n","hasSharedArrayBufferSupport":"var bool = hasSharedArrayBufferSupport()\n","hasSymbolSupport":"var bool = hasSymbolSupport()\n","hasToStringTagSupport":"var bool = hasToStringTagSupport()\n","hasUint8ArraySupport":"var bool = hasUint8ArraySupport()\n","hasUint8ClampedArraySupport":"var bool = hasUint8ClampedArraySupport()\n","hasUint16ArraySupport":"var bool = hasUint16ArraySupport()\n","hasUint32ArraySupport":"var bool = hasUint32ArraySupport()\n","hasWeakMapSupport":"var bool = hasWeakMapSupport()\n","hasWeakSetSupport":"var bool = hasWeakSetSupport()\n","hasWebAssemblySupport":"var bool = hasWebAssemblySupport()\n","HERNDON_VENUS_SEMIDIAMETERS":"var d = HERNDON_VENUS_SEMIDIAMETERS()\n","homedir":"var home = homedir()\n","HOURS_IN_DAY":"var days = 3.14;\nvar hrs = days * HOURS_IN_DAY\n","HOURS_IN_WEEK":"var wks = 3.14;\nvar hrs = wks * HOURS_IN_WEEK\n","hoursInMonth":"var num = hoursInMonth()\nnum = hoursInMonth( 2 )\nnum = hoursInMonth( 2, 2016 )\nnum = hoursInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = hoursInMonth( 'feb', 2016 )\nnum = hoursInMonth( 'february', 2016 )\n","hoursInYear":"var num = hoursInYear()\nnum = hoursInYear( 2016 )\nnum = hoursInYear( 2017 )\n","httpServer":"\n// Basic usage:\nvar createServer = httpServer()\n\n// Provide a request callback:\nfunction onRequest( request, response ) {\n console.log( request.url );\n response.end( 'OK' );\n};\ncreateServer = httpServer( onRequest )\n\n// Specify a specific port:\nvar opts = { 'port': 7331 };\ncreateServer = httpServer( opts )\n","identity":"var v = identity( 3.14 )\n","ifelse":"var z = ifelse( true, 1.0, -1.0 )\nz = ifelse( false, 1.0, -1.0 )\n","ifelseAsync":"function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, true );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifelseAsync( predicate, 'beep', 'boop', done )\n","ifthen":"function x() { return 1.0; };\nfunction y() { return -1.0; };\nvar z = ifthen( true, x, y )\nz = ifthen( false, x, y )\n","ifthenAsync":"function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, false );\n }\n};\nfunction x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'beep' );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifthenAsync( predicate, x, y, done )\n","imag":"var z = new Complex128( 5.0, 3.0 );\nvar im = imag( z )\n","IMG_ACANTHUS_MOLLIS":"var img = IMG_ACANTHUS_MOLLIS()\n","IMG_AIRPLANE_FROM_ABOVE":"var img = IMG_AIRPLANE_FROM_ABOVE()\n","IMG_ALLIUM_OREOPHILUM":"var img = IMG_ALLIUM_OREOPHILUM()\n","IMG_BLACK_CANYON":"var img = IMG_BLACK_CANYON()\n","IMG_DUST_BOWL_HOME":"var img = IMG_DUST_BOWL_HOME()\n","IMG_FRENCH_ALPINE_LANDSCAPE":"var img = IMG_FRENCH_ALPINE_LANDSCAPE()\n","IMG_LOCOMOTION_HOUSE_CAT":"var img = IMG_LOCOMOTION_HOUSE_CAT()\n","IMG_LOCOMOTION_NUDE_MALE":"var img = IMG_LOCOMOTION_NUDE_MALE()\n","IMG_MARCH_PASTORAL":"var img = IMG_MARCH_PASTORAL()\n","IMG_NAGASAKI_BOATS":"var img = IMG_NAGASAKI_BOATS()\n","incrapcorr":"var accumulator = incrapcorr();\nvar ar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator()\n","incrcount":"var accumulator = incrcount();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n","incrcovariance":"var accumulator = incrcovariance();\nvar v = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator()\n","incrcovmat":"var accumulator = incrcovmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n","incrcv":"var accumulator = incrcv();\nvar cv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator()\n","increwmean":"var accumulator = increwmean( 0.5 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n","increwstdev":"var accumulator = increwstdev( 0.5 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","increwvariance":"var accumulator = increwvariance( 0.5 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n","incrgmean":"var accumulator = incrgmean();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrgrubbs":"var acc = incrgrubbs();\nvar res = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n","incrhmean":"var accumulator = incrhmean();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrkmeans":"var accumulator = incrkmeans( 5, 2 );\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v );\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v );\n","incrkurtosis":"var accumulator = incrkurtosis();\nvar v = accumulator( 2.0 )\nv = accumulator( 2.0 )\nv = accumulator( -4.0 )\nv = accumulator( -4.0 )\n","incrmaape":"var accumulator = incrmaape();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n","incrmae":"var accumulator = incrmae();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n","incrmapcorr":"var accumulator = incrmapcorr( 3 );\nvar ar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator( 3.0, -1.0 )\nar = accumulator( 5.0, -9.5 )\nar = accumulator()\n","incrmape":"var accumulator = incrmape();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n","incrmax":"var accumulator = incrmax();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n","incrmaxabs":"var accumulator = incrmaxabs();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n","incrmcovariance":"var accumulator = incrmcovariance( 3 );\nvar v = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator( 3.0, -1.0 )\nv = accumulator( 5.0, -9.5 )\nv = accumulator()\n","incrmcv":"var accumulator = incrmcv( 3 );\nvar cv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator( 3.0 )\ncv = accumulator( 7.0 )\ncv = accumulator()\n","incrmda":"var accumulator = incrmda();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 4.0 )\nm = accumulator()\n","incrme":"var accumulator = incrme();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n","incrmean":"var accumulator = incrmean();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n","incrmeanabs":"var accumulator = incrmeanabs();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n","incrmeanabs2":"var accumulator = incrmeanabs2();\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n","incrmeanstdev":"var accumulator = incrmeanstdev();\nvar ms = accumulator()\nms = accumulator( 2.0 )\nms = accumulator( -5.0 )\nms = accumulator( 3.0 )\nms = accumulator( 5.0 )\nms = accumulator()\n","incrmeanvar":"var accumulator = incrmeanvar();\nvar mv = accumulator()\nmv = accumulator( 2.0 )\nmv = accumulator( -5.0 )\nmv = accumulator( 3.0 )\nmv = accumulator( 5.0 )\nmv = accumulator()\n","incrmgmean":"var accumulator = incrmgmean( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrmgrubbs":"var acc = incrmgrubbs( 20 );\nvar res = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n","incrmhmean":"var accumulator = incrmhmean( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrmidrange":"var accumulator = incrmidrange();\nvar v = accumulator()\nv = accumulator( 3.14 )\nv = accumulator( -5.0 )\nv = accumulator( 10.1 )\nv = accumulator()\n","incrmin":"var accumulator = incrmin();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n","incrminabs":"var accumulator = incrminabs();\nvar m = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n","incrminmax":"var accumulator = incrminmax();\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n","incrminmaxabs":"var accumulator = incrminmaxabs();\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n","incrmmaape":"var accumulator = incrmmaape( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n","incrmmae":"var accumulator = incrmmae( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n","incrmmape":"var accumulator = incrmmape( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n","incrmmax":"var accumulator = incrmmax( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n","incrmmaxabs":"var accumulator = incrmmaxabs( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n","incrmmda":"var accumulator = incrmmda( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 4.0, 5.0 )\nm = accumulator()\n","incrmme":"var accumulator = incrmme( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n","incrmmean":"var accumulator = incrmmean( 3 );\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n","incrmmeanabs":"var accumulator = incrmmeanabs( 3 );\nvar mu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n","incrmmeanabs2":"var accumulator = incrmmeanabs2( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n","incrmmeanstdev":"var accumulator = incrmmeanstdev( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrmmeanvar":"var accumulator = incrmmeanvar( 3 );\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n","incrmmidrange":"var accumulator = incrmmidrange( 3 );\nvar mr = accumulator()\nmr = accumulator( 2.0 )\nmr = accumulator( -5.0 )\nmr = accumulator( 3.0 )\nmr = accumulator( 5.0 )\nmr = accumulator()\n","incrmmin":"var accumulator = incrmmin( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n","incrmminabs":"var accumulator = incrmminabs( 3 );\nvar m = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n","incrmminmax":"var accumulator = incrmminmax( 3 );\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n","incrmminmaxabs":"var accumulator = incrmminmaxabs( 3 );\nvar mm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n","incrmmpe":"var accumulator = incrmmpe( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n","incrmmse":"var accumulator = incrmmse( 3 );\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n","incrmpcorr":"var accumulator = incrmpcorr( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator( 3.0, -1.0 )\nr = accumulator( 5.0, -9.5 )\nr = accumulator()\n","incrmpcorr2":"var accumulator = incrmpcorr2( 3 );\nvar r2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator( 3.0, -1.0 )\nr2 = accumulator( 5.0, -9.5 )\nr2 = accumulator()\n","incrmpcorrdist":"var accumulator = incrmpcorrdist( 3 );\nvar d = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator( 3.0, -1.0 )\nd = accumulator( 5.0, -9.5 )\nd = accumulator()\n","incrmpe":"var accumulator = incrmpe();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n","incrmprod":"var accumulator = incrmprod( 3 );\nvar p = accumulator()\np = accumulator( 2.0 )\np = accumulator( -5.0 )\np = accumulator( 3.0 )\np = accumulator( 5.0 )\np = accumulator()\n","incrmrange":"var accumulator = incrmrange( 3 );\nvar r = accumulator()\nr = accumulator( 2.0 )\nr = accumulator( -5.0 )\nr = accumulator( 3.0 )\nr = accumulator( 5.0 )\nr = accumulator()\n","incrmrmse":"var accumulator = incrmrmse( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n","incrmrss":"var accumulator = incrmrss( 3 );\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n","incrmse":"var accumulator = incrmse();\nvar m = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n","incrmstdev":"var accumulator = incrmstdev( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n","incrmsum":"var accumulator = incrmsum( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n","incrmsumabs":"var accumulator = incrmsumabs( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrmsumabs2":"var accumulator = incrmsumabs2( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrmsummary":"var accumulator = incrmsummary( 3 );\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrmsumprod":"var accumulator = incrmsumprod( 3 );\nvar s = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator( 3.0, -2.0 )\ns = accumulator( 5.0, 3.0 )\ns = accumulator()\n","incrmvariance":"var accumulator = incrmvariance( 3 );\nvar s2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator( 3.0 )\ns2 = accumulator( 5.0 )\ns2 = accumulator()\n","incrmvmr":"var accumulator = incrmvmr( 3 );\nvar F = accumulator()\nF = accumulator( 2.0 )\nF = accumulator( 1.0 )\nF = accumulator( 3.0 )\nF = accumulator( 7.0 )\nF = accumulator()\n","incrpcorr":"var accumulator = incrpcorr();\nvar r = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator()\n","incrpcorr2":"var accumulator = incrpcorr2();\nvar r2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator()\n","incrpcorrdist":"var accumulator = incrpcorrdist();\nvar d = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator()\n","incrpcorrdistmat":"var accumulator = incrpcorrdistmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n","incrpcorrmat":"var accumulator = incrpcorrmat( 2 );\nvar out = accumulator()\nvar vec = ndarray( 'float64', 1 );\nvar buf = new Float64Array( 2 );\nvar shape = [ 2 ];\nvar strides = [ 1 ];\nvar v = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n","incrprod":"var accumulator = incrprod();\nvar v = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n","incrrange":"var accumulator = incrrange();\nvar v = accumulator()\nv = accumulator( -2.0 )\nv = accumulator( 1.0 )\nv = accumulator( 3.0 )\nv = accumulator()\n","incrrmse":"var accumulator = incrrmse();\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n","incrrss":"var accumulator = incrrss();\nvar r = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n","incrskewness":"var accumulator = incrskewness();\nvar v = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( -10.0 )\nv = accumulator()\n","incrspace":"var arr = incrspace( 0, 11, 2 )\n","incrstdev":"var accumulator = incrstdev();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrsum":"var accumulator = incrsum();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrsumabs":"var accumulator = incrsumabs();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrsumabs2":"var accumulator = incrsumabs2();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrsummary":"var accumulator = incrsummary();\nvar s = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n","incrsumprod":"var accumulator = incrsumprod();\nvar s = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator()\n","incrvariance":"var accumulator = incrvariance();\nvar s2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator()\n","incrvmr":"var accumulator = incrvmr();\nvar D = accumulator()\nD = accumulator( 2.0 )\nD = accumulator( 1.0 )\nD = accumulator()\n","incrwmean":"var accumulator = incrwmean();\nvar mu = accumulator()\nmu = accumulator( 2.0, 1.0 )\nmu = accumulator( 2.0, 0.5 )\nmu = accumulator( 3.0, 1.5 )\nmu = accumulator()\n","ind2sub":"var d = [ 3, 3, 3 ];\nvar s = ind2sub( d, 17 )\n\n// Provide an output array:\nvar out = new Array( d.length );\ns = ind2sub( out, d, 17 )\nvar bool = ( s === out )\n","indexOf":"\n// Basic usage:\nvar arr = [ 4, 3, 2, 1 ];\nvar idx = indexOf( arr, 3 )\narr = [ 4, 3, 2, 1 ];\nidx = indexOf( arr, 5 )\n\n// Using a `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, 3 )\n\n// `fromIndex` which exceeds `array` length:\narr = [ 1, 2, 3, 4, 2, 5 ];\nidx = indexOf( arr, 2, 10 )\n\n// Negative `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6, 2 ];\nidx = indexOf( arr, 2, -4 )\nidx = indexOf( arr, 2, -1 )\n\n// Negative `fromIndex` exceeding input `array` length:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, -10 )\n\n// Array-like objects:\nvar str = 'bebop';\nidx = indexOf( str, 'o' )\n","inherit":"\n// Create a parent constructor:\nfunction Foo() { return this; };\nFoo.prototype.beep = function beep() { return 'boop'; };\n\n// Create a child constructor:\nfunction Bar() { Foo.call( this ); return this; };\n\n// Setup inheritance:\ninherit( Bar, Foo );\nvar bar = new Bar();\nvar v = bar.beep()\n","inheritedEnumerableProperties":"var props = inheritedEnumerableProperties( {} )\n","inheritedEnumerablePropertySymbols":"var symbols = inheritedEnumerablePropertySymbols( [] )\n","inheritedKeys":"var keys = inheritedKeys( {} )\n","inheritedNonEnumerableProperties":"var props = inheritedNonEnumerableProperties( {} )\n","inheritedNonEnumerablePropertyNames":"var keys = inheritedNonEnumerablePropertyNames( {} )\n","inheritedNonEnumerablePropertySymbols":"var symbols = inheritedNonEnumerablePropertySymbols( [] )\n","inheritedProperties":"var symbols = inheritedProperties( [] )\n","inheritedPropertyDescriptor":"var desc = inheritedPropertyDescriptor( {}, 'toString' )\n","inheritedPropertyDescriptors":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar desc = inheritedPropertyDescriptors( obj )\n","inheritedPropertyNames":"var keys = inheritedPropertyNames( [] )\n","inheritedPropertySymbols":"var symbols = inheritedPropertySymbols( [] )\n","inheritedWritableProperties":"var props = inheritedWritableProperties( {} )\n","inheritedWritablePropertyNames":"var keys = inheritedWritablePropertyNames( {} )\n","inheritedWritablePropertySymbols":"var symbols = inheritedWritablePropertySymbols( [] )\n","inmap":"function foo( v, i ) { return v * i; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = inmap( arr, foo )\nvar bool = ( out === arr )\n","inmapAsync":"\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n","inmapRight":"function foo( v, i ) { console.log( '%s: %d', i, v ); return v * i; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = inmapRight( arr, foo )\nvar bool = ( out === arr )\n","inmapRightAsync":"\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n","inspectSinkStream":"function clbk( chunk, idx ) { console.log( chunk.toString() ); };\nvar s = inspectSinkStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","inspectStream":"function clbk( chunk, idx ) { console.log( chunk.toString() ); };\nvar s = inspectStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","instanceOf":"var bool = instanceOf( [], Array )\nbool = instanceOf( {}, Object )\nbool = instanceOf( null, Object )\n","INT8_MAX":"INT8_MAX\n","INT8_MIN":"INT8_MIN\n","INT8_NUM_BYTES":"INT8_NUM_BYTES\n","Int8Array":"var arr = new Int8Array()\n","INT16_MAX":"INT16_MAX\n","INT16_MIN":"INT16_MIN\n","INT16_NUM_BYTES":"INT16_NUM_BYTES\n","Int16Array":"var arr = new Int16Array()\n","INT32_MAX":"INT32_MAX\n","INT32_MIN":"INT32_MIN\n","INT32_NUM_BYTES":"INT32_NUM_BYTES\n","Int32Array":"var arr = new Int32Array()\n","IS_BIG_ENDIAN":"IS_BIG_ENDIAN\n","IS_BROWSER":"IS_BROWSER\n","IS_DARWIN":"IS_DARWIN\n","IS_ELECTRON":"IS_ELECTRON\n","IS_ELECTRON_MAIN":"IS_ELECTRON_MAIN\n","IS_ELECTRON_RENDERER":"IS_ELECTRON_RENDERER\n","IS_LITTLE_ENDIAN":"IS_LITTLE_ENDIAN\n","IS_NODE":"IS_NODE\n","IS_WEB_WORKER":"IS_WEB_WORKER\n","IS_WINDOWS":"IS_WINDOWS\n","isAbsolutePath":"\n// Windows environment:\nvar bool = isAbsolutePath( 'C:\\\\foo\\\\bar\\\\baz' )\n\n// POSIX environment:\nbool = isAbsolutePath( '/foo/bar/baz' )\n","isAccessorProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isAccessorProperty( obj, 'boop' )\nbool = isAccessorProperty( obj, 'beep' )\n","isAccessorPropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isAccessorPropertyIn( obj, 'boop' )\nbool = isAccessorPropertyIn( obj, 'beep' )\n","isAlphagram":"var out = isAlphagram( 'beep' )\nout = isAlphagram( 'zba' )\nout = isAlphagram( '' )\n","isAlphaNumeric":"var bool = isAlphaNumeric( 'abc0123456789' )\nbool = isAlphaNumeric( 'abcdef' )\nbool = isAlphaNumeric( '0xff' )\nbool = isAlphaNumeric( '' )\n","isAnagram":"var str1 = 'I am a weakish speller';\nvar str2 = 'William Shakespeare';\nvar bool = isAnagram( str1, str2 )\nbool = isAnagram( 'bat', 'tabba' )\n","isArguments":"function foo() { return arguments; };\nvar bool = isArguments( foo() )\nbool = isArguments( [] )\n","isArray":"var bool = isArray( [] )\nbool = isArray( {} )\n","isArrayArray":"var bool = isArrayArray( [ [], [] ] )\nbool = isArrayArray( [ {}, {} ] )\nbool = isArrayArray( [] )\n","isArrayBuffer":"var bool = isArrayBuffer( new ArrayBuffer( 10 ) )\nbool = isArrayBuffer( [] )\n","isArrayLength":"var bool = isArrayLength( 5 )\nbool = isArrayLength( 2.0e200 )\nbool = isArrayLength( -3.14 )\nbool = isArrayLength( null )\n","isArrayLike":"var bool = isArrayLike( [] )\nbool = isArrayLike( { 'length': 10 } )\nbool = isArrayLike( 'beep' )\nbool = isArrayLike( null )\n","isArrayLikeObject":"var bool = isArrayLikeObject( [] )\nbool = isArrayLikeObject( { 'length': 10 } )\nbool = isArrayLikeObject( 'beep' )\n","isASCII":"var str = 'beep boop';\nvar bool = isASCII( str )\nbool = isASCII( fromCodePoint( 130 ) )\n","isBetween":"var bool = isBetween( 3.14, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.0, 4.0 )\nbool = isBetween( 4.0, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.14, 4.0 )\nbool = isBetween( 3.14, 3.14, 4.0, 'open', 'closed' )\nbool = isBetween( 3.14, 3.0, 3.14, 'closed', 'open' )\n","isBetweenArray":"var arr = [ 3.0, 3.14, 4.0 ];\nvar bool = isBetweenArray( arr, 3.0, 4.0 )\nbool = isBetweenArray( arr, 3.14, 4.0 )\nbool = isBetweenArray( arr, 3.0, 3.14 )\nbool = isBetweenArray( arr, 3.0, 4.0, 'open', 'closed' )\nbool = isBetweenArray( arr, 3.0, 4.0, 'closed', 'open' )\n","isBinaryString":"var bool = isBinaryString( '1000101' )\nbool = isBinaryString( 'beep' )\nbool = isBinaryString( '' )\n","isBoolean":"var bool = isBoolean( false )\nbool = isBoolean( new Boolean( false ) )\n","isBooleanArray":"var bool = isBooleanArray( [ true, false, true ] )\nbool = isBooleanArray( [ true, 'abc', false ] )\n","isBoxedPrimitive":"var bool = isBoxedPrimitive( new Boolean( false ) )\nbool = isBoxedPrimitive( true )\n","isBuffer":"var bool = isBuffer( new Buffer( 'beep' ) )\nbool = isBuffer( new Buffer( [ 1, 2, 3, 4 ] ) )\nbool = isBuffer( {} )\nbool = isBuffer( [] )\n","isCapitalized":"var bool = isCapitalized( 'Hello' )\nbool = isCapitalized( 'world' )\n","isCentrosymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 2, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isCentrosymmetricMatrix( M )\nbool = isCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isCentrosymmetricMatrix( 3.14 )\nbool = isCentrosymmetricMatrix( {} )\n","isCircular":"var obj = { 'beep': 'boop' };\nobj.self = obj;\nvar bool = isCircular( obj )\nbool = isCircular( {} )\nbool = isCircular( null )\n","isCircularArray":"var arr = [ 1, 2, 3 ];\narr.push( arr );\nvar bool = isCircularArray( arr )\nbool = isCircularArray( [] )\nbool = isCircularArray( null )\n","isCircularPlainObject":"var obj = { 'beep': 'boop' };\nobj.self = obj;\nvar bool = isCircularPlainObject( obj )\nbool = isCircularPlainObject( {} )\nbool = isCircularPlainObject( null )\n","isCollection":"var bool = isCollection( [] )\nbool = isCollection( { 'length': 0 } )\nbool = isCollection( {} )\n","isComplex":"var bool = isComplex( new Complex64( 2.0, 2.0 ) )\nbool = isComplex( new Complex128( 3.0, 1.0 ) )\nbool = isComplex( 3.14 )\nbool = isComplex( {} )\n","isComplex64":"var bool = isComplex64( new Complex64( 2.0, 2.0 ) )\nbool = isComplex64( new Complex128( 3.0, 1.0 ) )\nbool = isComplex64( 3.14 )\nbool = isComplex64( {} )\n","isComplex64Array":"var bool = isComplex64Array( new Complex64Array( 10 ) )\nbool = isComplex64Array( [] )\n","isComplex128":"var bool = isComplex128( new Complex128( 3.0, 1.0 ) )\nbool = isComplex128( new Complex64( 2.0, 2.0 ) )\nbool = isComplex128( 3.14 )\nbool = isComplex128( {} )\n","isComplex128Array":"var bool = isComplex128Array( new Complex128Array( 10 ) )\nbool = isComplex128Array( [] )\n","isComplexLike":"var bool = isComplexLike( new Complex64( 2.0, 2.0 ) )\nbool = isComplexLike( new Complex128( 3.0, 1.0 ) )\nbool = isComplexLike( 3.14 )\nbool = isComplexLike( {} )\n","isComplexTypedArray":"var bool = isComplexTypedArray( new Complex64Array( 10 ) )\n","isConfigurableProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isConfigurableProperty( obj, 'boop' )\nbool = isConfigurableProperty( obj, 'beep' )\n","isConfigurablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isConfigurablePropertyIn( obj, 'boop' )\nbool = isConfigurablePropertyIn( obj, 'beep' )\n","isDataProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isDataProperty( obj, 'boop' )\nbool = isDataProperty( obj, 'beep' )\n","isDataPropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isDataPropertyIn( obj, 'boop' )\nbool = isDataPropertyIn( obj, 'beep' )\n","isDateObject":"var bool = isDateObject( new Date() )\nbool = isDateObject( '2017-01-01' )\n","isDigitString":"var bool = isDigitString( '0123456789' )\nbool = isDigitString( 'abcdef' )\nbool = isDigitString( '0xff' )\nbool = isDigitString( '' )\n","isEmailAddress":"var bool = isEmailAddress( 'beep@boop.com' )\nbool = isEmailAddress( 'beep' )\nbool = isEmailAddress( null )\n","isEmptyArray":"var bool = isEmptyArray( [] )\nbool = isEmptyArray( [ 1, 2, 3 ] )\nbool = isEmptyArray( {} )\n","isEmptyObject":"var bool = isEmptyObject( {} )\nbool = isEmptyObject( { 'beep': 'boop' } )\nbool = isEmptyObject( [] )\n","isEmptyString":"var bool = isEmptyString( '' )\nbool = isEmptyString( new String( '' ) )\nbool = isEmptyString( 'beep' )\nbool = isEmptyString( [] )\n","isEnumerableProperty":"var beep = { 'boop': true };\nvar bool = isEnumerableProperty( beep, 'boop' )\nbool = isEnumerableProperty( beep, 'hasOwnProperty' )\n","isEnumerablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isEnumerablePropertyIn( obj, 'boop' )\nbool = isEnumerablePropertyIn( obj, 'beep' )\n","isError":"var bool = isError( new Error( 'beep' ) )\nbool = isError( {} )\n","isEvalError":"var bool = isEvalError( new EvalError( 'beep' ) )\nbool = isEvalError( {} )\n","isEven":"var bool = isEven( 4.0 )\nbool = isEven( new Number( 4.0 ) )\nbool = isEven( 3.0 )\nbool = isEven( -3.14 )\nbool = isEven( null )\n","isFalsy":"var bool = isFalsy( false )\nbool = isFalsy( '' )\nbool = isFalsy( 0 )\nbool = isFalsy( null )\nbool = isFalsy( void 0 )\nbool = isFalsy( NaN )\nbool = isFalsy( {} )\nbool = isFalsy( [] )\n","isFalsyArray":"var bool = isFalsyArray( [ null, '' ] )\nbool = isFalsyArray( [ {}, [] ] )\nbool = isFalsyArray( [] )\n","isFinite":"var bool = isFinite( 5.0 )\nbool = isFinite( new Number( 5.0 ) )\nbool = isFinite( 1.0/0.0 )\nbool = isFinite( null )\n","isFiniteArray":"var bool = isFiniteArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isFiniteArray( [ -3.0, 1.0/0.0 ] )\n","isFloat32Array":"var bool = isFloat32Array( new Float32Array( 10 ) )\nbool = isFloat32Array( [] )\n","isFloat64Array":"var bool = isFloat64Array( new Float64Array( 10 ) )\nbool = isFloat64Array( [] )\n","isFunction":"function beep() {};\nvar bool = isFunction( beep )\nbool = isFunction( {} )\n","isFunctionArray":"function beep() {};\nfunction boop() {};\nvar bool = isFunctionArray( [ beep, boop ] )\nbool = isFunctionArray( [ {}, beep ] )\nbool = isFunctionArray( [] )\n","isGeneratorObject":"function* generateID() {\n var idx = 0;\n while ( idx < idx+1 ) {\n yield idx;\n idx += 1;\n }\n};\nvar bool = isGeneratorObject( generateID() )\nbool = isGeneratorObject( generateID )\nbool = isGeneratorObject( {} )\nbool = isGeneratorObject( null )\n","isGeneratorObjectLike":"var obj = {\n 'next': function noop() {},\n 'return': function noop() {},\n 'throw': function noop() {}\n};\nvar bool = isGeneratorObjectLike( obj )\nbool = isGeneratorObjectLike( {} )\nbool = isGeneratorObjectLike( null )\n","isHexString":"var bool = isHexString( '0123456789abcdefABCDEF' )\nbool = isHexString( '0xffffff' )\nbool = isHexString( 'x' )\nbool = isHexString( '' )\n","isInfinite":"var bool = isInfinite( 1.0/0.0 )\nbool = isInfinite( new Number( -1.0/0.0 ) )\nbool = isInfinite( 5.0 )\nbool = isInfinite( '1.0/0.0' )\n","isInheritedProperty":"var beep = { 'boop': true };\nvar bool = isInheritedProperty( beep, 'boop' )\nbool = isInheritedProperty( beep, 'toString' )\nbool = isInheritedProperty( beep, 'bop' )\n","isInt8Array":"var bool = isInt8Array( new Int8Array( 10 ) )\nbool = isInt8Array( [] )\n","isInt16Array":"var bool = isInt16Array( new Int16Array( 10 ) )\nbool = isInt16Array( [] )\n","isInt32Array":"var bool = isInt32Array( new Int32Array( 10 ) )\nbool = isInt32Array( [] )\n","isInteger":"var bool = isInteger( 5.0 )\nbool = isInteger( new Number( 5.0 ) )\nbool = isInteger( -3.14 )\nbool = isInteger( null )\n","isIntegerArray":"var bool = isIntegerArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isIntegerArray( [ -3.0, '3.0' ] )\n","isIterableLike":"var bool = isIterableLike( [ 1, 2, 3 ] )\nbool = isIterableLike( {} )\nbool = isIterableLike( null )\n","isIteratorLike":"var obj = {\n 'next': function noop() {}\n};\nvar bool = isIteratorLike( obj )\nbool = isIteratorLike( {} )\nbool = isIteratorLike( null )\n","isJSON":"var bool = isJSON( '{\"a\":5}' )\nbool = isJSON( '{a\":5}' )\n","isLeapYear":"var bool = isLeapYear( new Date() )\nbool = isLeapYear( 1996 )\nbool = isLeapYear( 2001 )\n","isLowercase":"var bool = isLowercase( 'hello' )\nbool = isLowercase( 'World' )\n","isMatrixLike":"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isMatrixLike( M )\nbool = isMatrixLike( [ 1, 2, 3, 4 ] )\nbool = isMatrixLike( 3.14 )\nbool = isMatrixLike( {} )\n","isMethod":"var beep = { 'boop': function beep() { return 'beep'; } };\nvar bool = isMethod( beep, 'boop' )\nbool = isMethod( beep, 'toString' )\n","isMethodIn":"var beep = { 'boop': true };\nvar bool = isMethodIn( beep, 'toString' )\nbool = isMethodIn( beep, 'boop' )\nbool = isMethodIn( beep, 'bop' )\n","isNamedTypedTupleLike":"var Point = namedtypedtuple( [ 'x', 'y' ] );\nvar p = new Point();\nvar bool = isNamedTypedTupleLike( p )\nbool = isNamedTypedTupleLike( [ 1, 2, 3, 4 ] )\nbool = isNamedTypedTupleLike( 3.14 )\nbool = isNamedTypedTupleLike( {} )\n","isnan":"var bool = isnan( NaN )\nbool = isnan( new Number( NaN ) )\nbool = isnan( 3.14 )\nbool = isnan( null )\n","isNaNArray":"var bool = isNaNArray( [ NaN, NaN, NaN ] )\nbool = isNaNArray( [ NaN, 2 ] )\n","isNativeFunction":"var bool = isNativeFunction( Date )\nfunction beep() {};\nbool = isNativeFunction( beep )\nbool = isNativeFunction( {} )\n","isndarrayLike":"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isndarrayLike( M )\nbool = isndarrayLike( [ 1, 2, 3, 4 ] )\nbool = isndarrayLike( 3.14 )\nbool = isndarrayLike( {} )\n","isNegativeInteger":"var bool = isNegativeInteger( -5.0 )\nbool = isNegativeInteger( new Number( -5.0 ) )\nbool = isNegativeInteger( 5.0 )\nbool = isNegativeInteger( -3.14 )\nbool = isNegativeInteger( null )\n","isNegativeIntegerArray":"var bool = isNegativeIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeIntegerArray( [ -3.0, '-3.0' ] )\n","isNegativeNumber":"var bool = isNegativeNumber( -5.0 )\nbool = isNegativeNumber( new Number( -5.0 ) )\nbool = isNegativeNumber( -3.14 )\nbool = isNegativeNumber( 5.0 )\nbool = isNegativeNumber( null )\n","isNegativeNumberArray":"var bool = isNegativeNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeNumberArray( [ -3.0, '-3.0' ] )\n","isNegativeZero":"var bool = isNegativeZero( -0.0 )\nbool = isNegativeZero( new Number( -0.0 ) )\nbool = isNegativeZero( -3.14 )\nbool = isNegativeZero( 0.0 )\nbool = isNegativeZero( null )\n","isNodeBuiltin":"var bool = isNodeBuiltin( 'cluster' )\nbool = isNodeBuiltin( 'crypto' )\nbool = isNodeBuiltin( 'fs-extra' )\nbool = isNodeBuiltin( '' )\n","isNodeDuplexStreamLike":"var Stream = require( 'stream' ).Duplex;\ns = new Stream();\nvar bool = isNodeDuplexStreamLike( s )\nbool = isNodeDuplexStreamLike( {} )\n","isNodeReadableStreamLike":"var Stream = require( 'stream' ).Readable;\ns = new Stream();\nvar bool = isNodeReadableStreamLike( s )\nbool = isNodeReadableStreamLike( {} )\n","isNodeREPL":"var bool = isNodeREPL()\n","isNodeStreamLike":"var Stream = require( 'stream' ).Stream;\ns = new Stream();\nvar bool = isNodeStreamLike( s )\nbool = isNodeStreamLike( {} )\n","isNodeTransformStreamLike":"var Stream = require( 'stream' ).Transform;\ns = new Stream();\nvar bool = isNodeTransformStreamLike( s )\nbool = isNodeTransformStreamLike( {} )\n","isNodeWritableStreamLike":"var Stream = require( 'stream' ).Writable;\ns = new Stream();\nvar bool = isNodeWritableStreamLike( s )\nbool = isNodeWritableStreamLike( {} )\n","isNonConfigurableProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonConfigurableProperty( obj, 'boop' )\nbool = isNonConfigurableProperty( obj, 'beep' )\n","isNonConfigurablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonConfigurablePropertyIn( obj, 'boop' )\nbool = isNonConfigurablePropertyIn( obj, 'beep' )\n","isNonEnumerableProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonEnumerableProperty( obj, 'boop' )\nbool = isNonEnumerableProperty( obj, 'beep' )\n","isNonEnumerablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isNonEnumerablePropertyIn( obj, 'boop' )\nbool = isNonEnumerablePropertyIn( obj, 'beep' )\n","isNonNegativeInteger":"var bool = isNonNegativeInteger( 5.0 )\nbool = isNonNegativeInteger( new Number( 5.0 ) )\nbool = isNonNegativeInteger( 3.14 )\nbool = isNonNegativeInteger( -5.0 )\nbool = isNonNegativeInteger( null )\n","isNonNegativeIntegerArray":"var bool = isNonNegativeIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeIntegerArray( [ 3.0, '3.0' ] )\n","isNonNegativeNumber":"var bool = isNonNegativeNumber( 5.0 )\nbool = isNonNegativeNumber( new Number( 5.0 ) )\nbool = isNonNegativeNumber( 3.14 )\nbool = isNonNegativeNumber( -5.0 )\nbool = isNonNegativeNumber( null )\n","isNonNegativeNumberArray":"var bool = isNonNegativeNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeNumberArray( [ 3.0, '3.0' ] )\n","isNonPositiveInteger":"var bool = isNonPositiveInteger( -5.0 )\nbool = isNonPositiveInteger( new Number( -5.0 ) )\nbool = isNonPositiveInteger( 5.0 )\nbool = isNonPositiveInteger( -3.14 )\nbool = isNonPositiveInteger( null )\n","isNonPositiveIntegerArray":"var bool = isNonPositiveIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveIntegerArray( [ -3.0, '-3.0' ] )\n","isNonPositiveNumber":"var bool = isNonPositiveNumber( -5.0 )\nbool = isNonPositiveNumber( new Number( -5.0 ) )\nbool = isNonPositiveNumber( -3.14 )\nbool = isNonPositiveNumber( 5.0 )\nbool = isNonPositiveNumber( null )\n","isNonPositiveNumberArray":"var bool = isNonPositiveNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveNumberArray( [ -3.0, '-3.0' ] )\n","isNonSymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isNonSymmetricMatrix( M )\nbool = isNonSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isNonSymmetricMatrix( 3.14 )\nbool = isNonSymmetricMatrix( {} )\n","isNull":"var bool = isNull( null )\nbool = isNull( true )\n","isNullArray":"var bool = isNullArray( [ null, null, null ] )\nbool = isNullArray( [ NaN, 2, null ] )\n","isNumber":"var bool = isNumber( 3.14 )\nbool = isNumber( new Number( 3.14 ) )\nbool = isNumber( NaN )\nbool = isNumber( null )\n","isNumberArray":"var bool = isNumberArray( [ 1, 2, 3 ] )\nbool = isNumberArray( [ '1', 2, 3 ] )\n","isNumericArray":"var bool = isNumericArray( new Int8Array( 10 ) )\nbool = isNumericArray( [ 1, 2, 3 ] )\nbool = isNumericArray( [ '1', '2', '3' ] )\n","isObject":"var bool = isObject( {} )\nbool = isObject( true )\n","isObjectArray":"var bool = isObjectArray( [ {}, new Number(3.0) ] )\nbool = isObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isObjectArray( [ {}, '3.0' ] )\n","isObjectLike":"var bool = isObjectLike( {} )\nbool = isObjectLike( [] )\nbool = isObjectLike( null )\n","isOdd":"var bool = isOdd( 5.0 )\nbool = isOdd( new Number( 5.0 ) )\nbool = isOdd( 4.0 )\nbool = isOdd( new Number( 4.0 ) )\nbool = isOdd( -3.14 )\nbool = isOdd( null )\n","isoWeeksInYear":"var num = isoWeeksInYear()\nnum = isoWeeksInYear( 2015 )\nnum = isoWeeksInYear( 2017 )\n","isPersymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 2, 3, 1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isPersymmetricMatrix( M )\nbool = isPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isPersymmetricMatrix( 3.14 )\nbool = isPersymmetricMatrix( {} )\n","isPlainObject":"var bool = isPlainObject( {} )\nbool = isPlainObject( null )\n","isPlainObjectArray":"var bool = isPlainObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isPlainObjectArray( [ {}, new Number(3.0) ] )\nbool = isPlainObjectArray( [ {}, '3.0' ] )\n","isPositiveInteger":"var bool = isPositiveInteger( 5.0 )\nbool = isPositiveInteger( new Number( 5.0 ) )\nbool = isPositiveInteger( 3.14 )\nbool = isPositiveInteger( -5.0 )\nbool = isPositiveInteger( null )\n","isPositiveIntegerArray":"var bool = isPositiveIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveIntegerArray( [ 3.0, '3.0' ] )\n","isPositiveNumber":"var bool = isPositiveNumber( 5.0 )\nbool = isPositiveNumber( new Number( 5.0 ) )\nbool = isPositiveNumber( 3.14 )\nbool = isPositiveNumber( -5.0 )\nbool = isPositiveNumber( null )\n","isPositiveNumberArray":"var bool = isPositiveNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveNumberArray( [ 3.0, '3.0' ] )\n","isPositiveZero":"var bool = isPositiveZero( 0.0 )\nbool = isPositiveZero( new Number( 0.0 ) )\nbool = isPositiveZero( -3.14 )\nbool = isPositiveZero( -0.0 )\nbool = isPositiveZero( null )\n","isPrimitive":"var bool = isPrimitive( true )\nbool = isPrimitive( {} )\n","isPrimitiveArray":"var bool = isPrimitiveArray( [ '3', 2, null ] )\nbool = isPrimitiveArray( [ {}, 2, 1 ] )\nbool = isPrimitiveArray( [ new String('abc'), '3.0' ] )\n","isPRNGLike":"var bool = isPRNGLike( base.random.randu )\nbool = isPRNGLike( [ 1, 2, 3, 4 ] )\nbool = isPRNGLike( 3.14 )\nbool = isPRNGLike( {} )\n","isProbability":"var bool = isProbability( 0.5 )\nbool = isProbability( new Number( 0.5 ) )\nbool = isProbability( 3.14 )\nbool = isProbability( -5.0 )\nbool = isProbability( null )\n","isProbabilityArray":"var bool = isProbabilityArray( [ 0.5, new Number(0.8) ] )\nbool = isProbabilityArray( [ 0.8, 1.2 ] )\nbool = isProbabilityArray( [ 0.8, '0.2' ] )\n","isPrototypeOf":"function Foo() { return this; };\nfunction Bar() { return this; };\ninherit( Bar, Foo );\nvar bar = new Bar();\nvar bool = isPrototypeOf( bar, Foo.prototype )\n","isRangeError":"var bool = isRangeError( new RangeError( 'beep' ) )\nbool = isRangeError( {} )\n","isReadableProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadableProperty( obj, 'boop' )\nbool = isReadableProperty( obj, 'beep' )\n","isReadablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadablePropertyIn( obj, 'boop' )\nbool = isReadablePropertyIn( obj, 'beep' )\n","isReadOnlyProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadOnlyProperty( obj, 'boop' )\nbool = isReadOnlyProperty( obj, 'beep' )\n","isReadOnlyPropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadOnlyPropertyIn( obj, 'boop' )\nbool = isReadOnlyPropertyIn( obj, 'beep' )\n","isReadWriteProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadWriteProperty( obj, 'boop' )\nbool = isReadWriteProperty( obj, 'beep' )\n","isReadWritePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isReadWritePropertyIn( obj, 'boop' )\nbool = isReadWritePropertyIn( obj, 'beep' )\n","isReferenceError":"var bool = isReferenceError( new ReferenceError( 'beep' ) )\nbool = isReferenceError( {} )\n","isRegExp":"var bool = isRegExp( /\\.+/ )\nbool = isRegExp( {} )\n","isRegExpString":"var bool = isRegExpString( '/beep/' )\nbool = isRegExpString( 'beep' )\nbool = isRegExpString( '' )\nbool = isRegExpString( null )\n","isRelativePath":"\n// Windows environments:\nvar bool = isRelativePath( 'foo\\\\bar\\\\baz' )\n\n// POSIX environments:\nbool = isRelativePath( './foo/bar/baz' )\n","isSafeInteger":"var bool = isSafeInteger( 5.0 )\nbool = isSafeInteger( new Number( 5.0 ) )\nbool = isSafeInteger( 2.0e200 )\nbool = isSafeInteger( -3.14 )\nbool = isSafeInteger( null )\n","isSafeIntegerArray":"var arr = [ -3.0, new Number(0.0), 2.0 ];\nvar bool = isSafeIntegerArray( arr )\narr = [ -3.0, '3.0' ];\nbool = isSafeIntegerArray( arr )\n","isSameValue":"var bool = isSameValue( true, true )\nbool = isSameValue( {}, {} )\nbool = isSameValue( -0.0, -0.0 )\nbool = isSameValue( -0.0, 0.0 )\nbool = isSameValue( NaN, NaN )\n","isSameValueZero":"var bool = isSameValueZero( true, true )\nbool = isSameValueZero( {}, {} )\nbool = isSameValueZero( -0.0, -0.0 )\nbool = isSameValueZero( -0.0, 0.0 )\nbool = isSameValueZero( NaN, NaN )\n","isSharedArrayBuffer":"\n// Assuming an environment supports SharedArrayBuffer...\nvar bool = isSharedArrayBuffer( new SharedArrayBuffer( 10 ) )\nbool = isSharedArrayBuffer( [] )\n","isSkewCentrosymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 2, 1, -1, -2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewCentrosymmetricMatrix( M )\nbool = isSkewCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewCentrosymmetricMatrix( 3.14 )\nbool = isSkewCentrosymmetricMatrix( {} )\n","isSkewPersymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 1, 0, 0, -1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewPersymmetricMatrix( M )\nbool = isSkewPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewPersymmetricMatrix( 3.14 )\nbool = isSkewPersymmetricMatrix( {} )\n","isSkewSymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, -1, 1, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSkewSymmetricMatrix( M )\nbool = isSkewSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewSymmetricMatrix( 3.14 )\nbool = isSkewSymmetricMatrix( {} )\n","isSquareMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSquareMatrix( M )\nbool = isSquareMatrix( [ 1, 2, 3, 4 ] )\nbool = isSquareMatrix( 3.14 )\nbool = isSquareMatrix( {} )\n","isStrictEqual":"var bool = isStrictEqual( true, true )\nbool = isStrictEqual( {}, {} )\nbool = isStrictEqual( -0.0, -0.0 )\nbool = isStrictEqual( -0.0, 0.0 )\nbool = isStrictEqual( NaN, NaN )\n","isString":"var bool = isString( 'beep' )\nbool = isString( new String( 'beep' ) )\nbool = isString( 5 )\n","isStringArray":"var bool = isStringArray( [ 'abc', 'def' ] )\nbool = isStringArray( [ 'abc', 123 ] )\n","isSymbol":"var bool = isSymbol( Symbol( 'beep' ) )\nbool = isSymbol( Object( Symbol( 'beep' ) ) )\nbool = isSymbol( {} )\nbool = isSymbol( null )\nbool = isSymbol( true )\n","isSymbolArray":"var bool = isSymbolArray( [ Symbol( 'beep' ), Symbol( 'boop' ) ] )\nbool = isSymbolArray( Symbol( 'beep' ) )\nbool = isSymbolArray( [] )\nbool = isSymbolArray( {} )\nbool = isSymbolArray( null )\nbool = isSymbolArray( true )\n","isSymmetricMatrix":"var mat = ndarray( 'generic', 2 );\nvar M = mat( [ 0, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nvar bool = isSymmetricMatrix( M )\nbool = isSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSymmetricMatrix( 3.14 )\nbool = isSymmetricMatrix( {} )\n","isSyntaxError":"var bool = isSyntaxError( new SyntaxError( 'beep' ) )\nbool = isSyntaxError( {} )\n","isTruthy":"bool = isTruthy( {} )\nbool = isTruthy( [] )\nbool = isTruthy( false )\nbool = isTruthy( '' )\nbool = isTruthy( 0 )\nbool = isTruthy( null )\nbool = isTruthy( void 0 )\nbool = isTruthy( NaN )\n","isTruthyArray":"var bool = isTruthyArray( [ {}, [] ] )\nbool = isTruthyArray( [ null, '' ] )\nbool = isTruthyArray( [] )\n","isTypedArray":"var bool = isTypedArray( new Int8Array( 10 ) )\n","isTypedArrayLength":"var bool = isTypedArrayLength( 5 )\nbool = isTypedArrayLength( 2.0e200 )\nbool = isTypedArrayLength( -3.14 )\nbool = isTypedArrayLength( null )\n","isTypedArrayLike":"var bool = isTypedArrayLike( new Int16Array() )\nbool = isTypedArrayLike({\n 'length': 10,\n 'byteOffset': 0,\n 'byteLength': 10,\n 'BYTES_PER_ELEMENT': 4\n})\n","isTypeError":"var bool = isTypeError( new TypeError( 'beep' ) )\nbool = isTypeError( {} )\n","isUint8Array":"var bool = isUint8Array( new Uint8Array( 10 ) )\nbool = isUint8Array( [] )\n","isUint8ClampedArray":"var bool = isUint8ClampedArray( new Uint8ClampedArray( 10 ) )\nbool = isUint8ClampedArray( [] )\n","isUint16Array":"var bool = isUint16Array( new Uint16Array( 10 ) )\nbool = isUint16Array( [] )\n","isUint32Array":"var bool = isUint32Array( new Uint32Array( 10 ) )\nbool = isUint32Array( [] )\n","isUNCPath":"var bool = isUNCPath( '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz' )\nbool = isUNCPath( '/foo/bar/baz' )\n","isUndefined":"var bool = isUndefined( void 0 )\nbool = isUndefined( null )\n","isUndefinedOrNull":"var bool = isUndefinedOrNull( void 0 )\nbool = isUndefinedOrNull( null )\nbool = isUndefinedOrNull( false )\n","isUnityProbabilityArray":"var bool = isUnityProbabilityArray( [ 0.25, 0.5, 0.25 ] )\nbool = isUnityProbabilityArray( new Uint8Array( [ 0, 1 ] ) )\nbool = isUnityProbabilityArray( [ 0.4, 0.4, 0.4 ] )\nbool = isUnityProbabilityArray( [ 3.14, 0.0 ] )\n","isUppercase":"var bool = isUppercase( 'HELLO' )\nbool = isUppercase( 'World' )\n","isURI":"var bool = isURI( 'http://google.com' )\nbool = isURI( 'http://localhost/' )\nbool = isURI( 'http://example.w3.org/path%20with%20spaces.html' )\nbool = isURI( 'ftp://ftp.is.co.za/rfc/rfc1808.txt' )\n\n// No scheme:\nbool = isURI( '' )\nbool = isURI( 'foo@bar' )\nbool = isURI( '://foo/' )\n\n// Illegal characters:\nbool = isURI( 'http://' )\n\n// Invalid path:\nbool = isURI( 'http:////foo.html' )\n\n// Incomplete hex escapes:\nbool = isURI( 'http://example.w3.org/%a' )\n","isURIError":"var bool = isURIError( new URIError( 'beep' ) )\nbool = isURIError( {} )\n","isVectorLike":"var M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 1;\nM.shape = [ 4 ];\nM.strides = [ 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nvar bool = isVectorLike( M )\nbool = isVectorLike( [ 1, 2, 3, 4 ] )\nbool = isVectorLike( 3.14 )\nbool = isVectorLike( {} )\n","isWhitespace":"var bool = isWhitespace( ' ' )\nbool = isWhitespace( 'abcdef' )\nbool = isWhitespace( '' )\n","isWritableProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isWritableProperty( obj, 'boop' )\nbool = isWritableProperty( obj, 'beep' )\n","isWritablePropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nvar bool = isWritablePropertyIn( obj, 'boop' )\nbool = isWritablePropertyIn( obj, 'beep' )\n","isWriteOnlyProperty":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isWriteOnlyProperty( obj, 'boop' )\nbool = isWriteOnlyProperty( obj, 'beep' )\n","isWriteOnlyPropertyIn":"var obj = { 'boop': true };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nvar bool = isWriteOnlyPropertyIn( obj, 'boop' )\nbool = isWriteOnlyPropertyIn( obj, 'beep' )\n","iterAdd":"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterAdd( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterAdvance":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar it = iterAdvance( arr, 4 );\nvar v = it.next().value\nvar bool = it.next().done\n","iterAny":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar bool = iterAny( arr )\n","iterAnyBy":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v === 1 ); };\nvar bool = iterAnyBy( arr, fcn )\n","iterator2array":"var opts = { 'iter': 10 };\nvar arr = iterator2array( random.iterators.randu( opts ) )\n","iterator2arrayview":"var it = random.iterators.randu({ 'iter': 10 });\nvar out = new Float64Array( 20 );\nvar arr = iterator2arrayview( it, out, 5, 15 )\n","iterator2arrayviewRight":"var it = random.iterators.randu({ 'iter': 10 });\nvar out = new Float64Array( 20 );\nvar arr = iterator2arrayviewRight( it, out, 5, 15 )\n","iteratorStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar it = random.iterators.randu( opts );\nvar s = iteratorStream( it );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","IteratorSymbol":"var s = IteratorSymbol\n","iterawgn":"var src = iterSineWave();\nvar it = iterawgn( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n","iterawln":"var src = iterSineWave();\nvar it = iterawln( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n","iterawun":"var src = iterSineWave();\nvar it = iterawun( src, 0.5 );\nvar v = it.next().value\nv = it.next().value\n","iterBartlettHannPulse":"var it = iterBartlettHannPulse();\nvar v = it.next().value\nv = it.next().value\n","iterBartlettPulse":"var it = iterBartlettPulse();\nvar v = it.next().value\nv = it.next().value\n","iterConcat":"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = array2iterator( [ 3, 4 ] );\nvar it = iterConcat( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterConstant":"var it = iterConstant( 3.14 );\nvar v = it.next().value\nv = it.next().value\n","iterCosineWave":"var it = iterCosineWave();\nvar v = it.next().value\nv = it.next().value\n","iterCounter":"var it = iterCounter( random.iterators.randu() );\nvar v = it.next().value\nv = it.next().value\n","itercugmean":"var arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nvar it = itercugmean( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n","itercuhmean":"var arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nvar it = itercuhmean( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n","itercumax":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumax( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercumaxabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumaxabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercumean":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumean( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercumeanabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumeanabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercumeanabs2":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumeanabs2( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercumidrange":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumidrange( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n","itercumin":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercumin( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercuminabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercuminabs( arr );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itercuprod":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercuprod( arr );\nvar p = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n","itercurange":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercurange( arr );\nvar r = it.next().value\nr = it.next().value\nr = it.next().value\nr = it.next().value\n","itercusum":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusum( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","itercusumabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusumabs( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","itercusumabs2":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itercusumabs2( arr );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","iterDedupe":"var arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nvar it = iterDedupe( arr );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\n","iterDedupeBy":"var arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nfunction fcn( v ) { return v; };\nvar it = iterDedupeBy( arr, fcn );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\n","iterDiracComb":"var it = iterDiracComb();\nvar v = it.next().value\nv = it.next().value\n","iterDivide":"var it1 = array2iterator( [ 3.0, 2.0 ] );\nvar it2 = array2iterator( [ 1.0, 4.0 ] );\nvar it = iterDivide( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterEmpty":"var it = iterEmpty();\nvar bool = it.next().done\n","iterEvery":"var arr = array2iterator( [ 1, 1, 1, 1, 0 ] );\nvar bool = iterEvery( arr )\n","iterEveryBy":"var arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nvar bool = iterEveryBy( arr, fcn )\n","iterFibonacci":"var it = iterFibonacci();\nvar v = it.next().value\nv = it.next().value\n","iterFill":"var it = iterFill( random.iterators.randu(), 3.14, 0, 2 );\nvar r = it.next().value\nr = it.next().value\nr = it.next().value\n","iterFilter":"function f( v ) { return ( v > 2 ); };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterFilter( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n","iterFilterMap":"function f( v ) { if ( v > 2 ) { return v * 10 }; };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterFilterMap( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n","iterFirst":"var arr = array2iterator( [ 1, 0, 0, 0, 0 ] );\nvar v = iterFirst( arr )\n","iterFlatTopPulse":"var it = iterFlatTopPulse();\nvar v = it.next().value\nv = it.next().value\n","iterFlow":"var o = {};\no.head = iterHead;\no.some = iterSome;\nvar fiter = iterFlow( o )\n","iterForEach":"function f( v ) { if ( v !== v ) { throw new Error( 'beep' ); } };\nvar it = iterForEach( random.iterators.randu(), f );\nvar r = it.next().value\nr = it.next().value\n","iterHannPulse":"var it = iterHannPulse();\nvar v = it.next().value\nv = it.next().value\n","iterHead":"var it = iterHead( random.iterators.randu(), 5 );\nvar r = it.next().value\nr = it.next().value\n","iterIntersection":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nvar it = iterIntersection( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterIntersectionByHash":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nfunction f( v ) { return v.toString(); };\nvar it = iterIntersectionByHash( it1, it2, f );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterLanczosPulse":"var it = iterLanczosPulse();\nvar v = it.next().value\nv = it.next().value\n","iterLast":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar v = iterLast( arr )\n","iterLength":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar len = iterLength( arr )\n","iterMap":"function f( v ) { return v * 10.0; };\nvar it = iterMap( random.iterators.randu(), f );\nvar r = it.next().value\nr = it.next().value\n","iterMapN":"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nfunction fcn( x, y ) { return x + y; };\nvar it = iterMapN( it1, it2, fcn );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","itermax":"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = itermax( arr )\n","itermaxabs":"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = itermaxabs( arr )\n","itermean":"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar m = itermean( arr )\n","itermeanabs":"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermeanabs( arr )\n","itermeanabs2":"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermeanabs2( arr )\n","itermidrange":"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar v = itermidrange( arr )\n","itermin":"var arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nvar m = itermin( arr )\n","iterminabs":"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar m = iterminabs( arr )\n","itermmax":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmax( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermmaxabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmaxabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermmean":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmean( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermmeanabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmeanabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermmeanabs2":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmeanabs2( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermmidrange":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmidrange( arr, 3 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n","itermmin":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermmin( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermminabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermminabs( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","iterMod":"var it1 = array2iterator( [ 3.0, 2.0 ] );\nvar it2 = array2iterator( [ 1.0, 4.0 ] );\nvar it = iterMod( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","itermprod":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermprod( arr, 3 );\nvar p = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n","itermrange":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermrange( arr, 3 );\nvar m = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n","itermsum":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsum( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","itermsumabs":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsumabs( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","itermsumabs2":"var arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nvar it = itermsumabs2( arr, 3 );\nvar s = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n","iterMultiply":"var it1 = array2iterator( [ 1.0, 2.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterMultiply( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterNone":"var arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nvar bool = iterNone( arr )\n","iterNoneBy":"var arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v <= 0 ); };\nvar bool = iterNoneBy( arr, fcn )\n","iterNonFibonacci":"var it = iterNonFibonacci();\nvar v = it.next().value\nv = it.next().value\n","iterNth":"var arr = array2iterator( [ 0, 0, 1, 0, 0 ] );\nvar v = iterNth( arr, 3 )\n","iterPeriodicSinc":"var it = iterPeriodicSinc( 7 );\nvar v = it.next().value\nv = it.next().value\n","iterPipeline":"var it1 = iterThunk( iterHead, 100 );\nfunction f( r ) { return ( r > 0.95 ); };\nvar it2 = iterThunk( iterSomeBy, 5, f );\nvar p = iterPipeline( it1, it2 );\nvar bool = p( random.iterators.randu() )\n","iterPop":"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterPop( it1 );\nvar v = it2.next().value\nvar bool = it2.next().done\n","iterprod":"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar s = iterprod( arr )\n","iterPulse":"var it = iterPulse();\nvar v = it.next().value\nv = it.next().value\n","iterPush":"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterPush( it1, 3, 4 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n","iterrange":"var arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nvar v = iterrange( arr )\n","iterReject":"function f( v ) { return ( v > 2 ); };\nvar it1 = array2iterator( [ 1, 3, 2, 4 ] );\nvar it2 = iterReject( it1, f );\nvar v = it2.next().value\nv = it2.next().value\n","iterReplicate":"var it1 = array2iterator( [ 1, 2, 3, 4 ] );\nvar it2 = iterReplicate( it1, 2 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n","iterReplicateBy":"var it1 = array2iterator( [ 1, 2, 3, 4 ] );\nfunction f( v, i ) { return i + 1; };\nvar it2 = iterReplicateBy( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n","iterSawtoothWave":"var it = iterSawtoothWave();\nvar v = it.next().value\nv = it.next().value\n","iterShift":"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterShift( it1 );\nvar v = it2.next().value\nvar bool = it2.next().done\n","iterSineWave":"var it = iterSineWave();\nvar v = it.next().value\nv = it.next().value\n","iterSlice":"var it = iterSlice( random.iterators.randu(), 5, 10 );\nvar r = it.next().value\nr = it.next().value\n","iterSome":"var arr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nvar bool = iterSome( arr, 3 )\n","iterSomeBy":"var arr = array2iterator( [ 1, 1, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nvar bool = iterSomeBy( arr, 3, fcn )\n","iterSquareWave":"var it = iterSquareWave();\nvar v = it.next().value\nv = it.next().value\n","iterstdev":"var arr = array2iterator( [ 2.0, -5.0 ] );\nvar m = iterstdev( arr )\n","iterSubtract":"var it1 = array2iterator( [ 1.0, 5.0 ] );\nvar it2 = array2iterator( [ 3.0, 4.0 ] );\nvar it = iterSubtract( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","itersum":"var arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nvar s = itersum( arr )\n","itersumabs":"var arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\nvar s = itersumabs( arr )\n","itersumabs2":"var arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\nvar s = itersumabs2( arr )\n","iterThunk":"var fcn = iterThunk( iterSome, 3 );\nvar arr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nvar bool = fcn( arr )\n","iterTriangleWave":"var it = iterTriangleWave();\nvar v = it.next().value\nv = it.next().value\n","iterUnion":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nvar it = iterUnion( it1, it2 );\nvar v = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nvar bool = it.next().done\n","iterUnique":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nvar it2 = iterUnique( it1 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n","iterUniqueBy":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( a, b ) { return ( a !== b ); };\nvar it2 = iterUniqueBy( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n","iterUniqueByHash":"var it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( v ) { return v.toString(); };\nvar it2 = iterUniqueByHash( it1, f );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n","iterUnshift":"var it1 = array2iterator( [ 1, 2 ] );\nvar it2 = iterUnshift( it1, 3, 4 );\nvar v = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nvar bool = it2.next().done\n","itervariance":"var arr = array2iterator( [ 2.0, -5.0 ] );\nvar s2 = itervariance( arr )\n","joinStream":"var s = joinStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","keyBy":"function toKey( v ) { return v.a; };\nvar arr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyBy( arr, toKey )\n","keyByRight":"function toKey( v ) { return v.a; };\nvar arr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyByRight( arr, toKey )\n","keysIn":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = keysIn( obj )\n","kruskalTest":"\n// Data from Hollander & Wolfe (1973), p. 116:\nvar x = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\nvar y = [ 3.8, 2.7, 4.0, 2.4 ];\nvar z = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nvar out = kruskalTest( x, y, z )\nvar 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];\nvar groups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = kruskalTest( arr, { 'groups': groups })\n","kstest":"\n// Verify that data is drawn from a normal distribution:\nvar rnorm = base.random.normal.factory({ 'seed': 4839 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < 100; i++ ) { x[ i ] = rnorm( 3.0, 1.0 ); }\n\n// Test against N(0,1)\nvar out = kstest( x, 'normal', 0.0, 1.0 )\n\n// Test against N(3,1)\nout = kstest( x, 'normal', 3.0, 1.0 )\n\n// Verify that data is drawn from a uniform distribution:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 })\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0 )\n\n// Print output:\nout.print()\n\n// Set custom significance level:\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alpha': 0.1 })\n\n// Carry out one-sided hypothesis tests:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'less' })\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'greater' })\n\n// Set `sorted` option to true when data is in increasing order:\nx = [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 ];\nout = kstest( x, 'uniform', 0.0, 1.0, { 'sorted': true })\n","LinkedList":"var list = LinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n","linspace":"var arr = linspace( 0, 100, 6 )\n","LIU_NEGATIVE_OPINION_WORDS_EN":"var list = LIU_NEGATIVE_OPINION_WORDS_EN()\n","LIU_POSITIVE_OPINION_WORDS_EN":"var list = LIU_POSITIVE_OPINION_WORDS_EN()\n","LN_HALF":"LN_HALF\n","LN_PI":"LN_PI\n","LN_SQRT_TWO_PI":"LN_SQRT_TWO_PI\n","LN_TWO_PI":"LN_TWO_PI\n","LN2":"LN2\n","LN10":"LN10\n","LOG2E":"LOG2E\n","LOG10E":"LOG10E\n","logspace":"var arr = logspace( 0, 2, 6 )\n","lowercase":"var out = lowercase( 'bEEp' )\n","lowercaseKeys":"var obj = { 'A': 1, 'B': 2 };\nvar out = lowercaseKeys( obj )\n","lowess":"var x = new Float64Array( 100 );\nvar y = new Float64Array( x.length );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = i;\n y[ i ] = ( 0.5*i ) + ( 10.0*base.random.randn() );\n}\nvar out = lowess( x, y );\nvar yhat = out.y;\nvar h = Plot( [ x, x ], [ y, yhat ] );\nh.lineStyle = [ 'none', '-' ];\nh.symbols = [ 'closed-circle', 'none' ];\nh.view( 'window' );\n","lpad":"var out = lpad( 'a', 5 )\nout = lpad( 'beep', 10, 'b' )\nout = lpad( 'boop', 12, 'beep' )\n","ltrim":"var out = ltrim( ' \\r\\n\\t Beep \\t\\t\\n ' )\n","MALE_FIRST_NAMES_EN":"var list = MALE_FIRST_NAMES_EN()\n","mapFun":"function fcn( i ) { return i; };\nvar arr = mapFun( fcn, 5 )\n","mapFunAsync":"\n// Basic usage:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nmapFunAsync( fcn, 10, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nvar opts = { 'limit': 2 };\nmapFunAsync( fcn, 10, opts, done )\n\n// Sequential invocation:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nvar opts = { 'series': true };\nmapFunAsync( fcn, 10, opts, done )\n","mapKeys":"function transform( key, value ) { return key + value; };\nvar obj = { 'a': 1, 'b': 2 };\nvar out = mapKeys( obj, transform )\n","mapKeysAsync":"\n// Basic usage:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar obj = { 'a': 1, 'b': 2 };\nmapKeysAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'limit': 2 };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'series': true };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n","mapValues":"function transform( value, key ) { return key + value; };\nvar obj = { 'a': 1, 'b': 2 };\nvar out = mapValues( obj, transform )\n","mapValuesAsync":"\n// Basic usage:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar obj = { 'a': 1, 'b': 2 };\nmapValuesAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'limit': 2 };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nvar opts = { 'series': true };\nvar obj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n","MAX_ARRAY_LENGTH":"MAX_ARRAY_LENGTH\n","MAX_TYPED_ARRAY_LENGTH":"MAX_TYPED_ARRAY_LENGTH\n","memoize":"function factorial( n ) {\n var prod;\n var i;\n prod = 1;\n for ( i = n; i > 1; i-- ) {\n prod *= i;\n }\n return prod;\n};\nvar memoized = memoize( factorial );\nvar v = memoized( 5 )\nv = memoized( 5 )\n","merge":"var target = { 'a': 'beep' };\nvar source = { 'a': 'boop', 'b': 'bap' };\nvar out = merge( target, source )\nvar bool = ( out === target )\n","MILLISECONDS_IN_DAY":"var days = 3.14;\nvar ms = days * MILLISECONDS_IN_DAY\n","MILLISECONDS_IN_HOUR":"var hrs = 3.14;\nvar ms = hrs * MILLISECONDS_IN_HOUR\n","MILLISECONDS_IN_MINUTE":"var mins = 3.14;\nvar ms = mins * MILLISECONDS_IN_MINUTE\n","MILLISECONDS_IN_SECOND":"var secs = 3.14;\nvar ms = secs * MILLISECONDS_IN_SECOND\n","MILLISECONDS_IN_WEEK":"var weeks = 3.14;\nvar ms = weeks * MILLISECONDS_IN_WEEK\n","MINARD_NAPOLEONS_MARCH":"var data = MINARD_NAPOLEONS_MARCH();\nvar army = data.army\nvar cities = data.cities\nvar labels = data.labels\nvar river = data.river\nvar t = data.temperature\n","MINUTES_IN_DAY":"var days = 3.14;\nvar mins = days * MINUTES_IN_DAY\n","MINUTES_IN_HOUR":"var hrs = 3.14;\nvar mins = hrs * MINUTES_IN_HOUR\n","MINUTES_IN_WEEK":"var wks = 3.14;\nvar mins = wks * MINUTES_IN_WEEK\n","minutesInMonth":"var num = minutesInMonth()\nnum = minutesInMonth( 2 )\nnum = minutesInMonth( 2, 2016 )\nnum = minutesInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = minutesInMonth( 'feb', 2016 )\nnum = minutesInMonth( 'february', 2016 )\n","minutesInYear":"var num = minutesInYear()\nnum = minutesInYear( 2016 )\nnum = minutesInYear( 2017 )\n","MOBY_DICK":"var data = MOBY_DICK()\n","MONTH_NAMES_EN":"var list = MONTH_NAMES_EN()\n","MONTHS_IN_YEAR":"var yrs = 3.14;\nvar mons = yrs * MONTHS_IN_YEAR\n","moveProperty":"var obj1 = { 'a': 'b' };\nvar obj2 = {};\nvar bool = moveProperty( obj1, 'a', obj2 )\nbool = moveProperty( obj1, 'c', obj2 )\n","namedtypedtuple":"var opts = {};\nopts.name = 'Point';\nvar factory = namedtypedtuple( [ 'x', 'y' ], opts );\nvar tuple = factory();\n","nativeClass":"var str = nativeClass( 'a' )\nstr = nativeClass( 5 )\nfunction Beep(){};\nstr = nativeClass( new Beep() )\n","ndarray":"var ctor = ndarray( 'generic', 2 )\n\n// To create a new instance...\nvar b = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n","ndarrayCastingModes":"var out = ndarrayCastingModes()\n","ndarrayDataTypes":"var out = ndarrayDataTypes()\n","ndarrayIndexModes":"var out = ndarrayIndexModes()\n","ndarrayMemoized":"var ctor = ndarrayMemoized( 'generic', 2 )\nvar f = ndarrayMemoized( 'generic', 2 )\nvar bool = ( f === ctor )\n\n// To create a new instance...\nvar b = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nvar d = [ 2, 2 ]; // shape\nvar s = [ 2, 1 ]; // strides\nvar o = 0; // index offset\nvar arr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nvar v = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n","ndarrayMinDataType":"var dt = ndarrayMinDataType( 3.141592653589793 )\ndt = ndarrayMinDataType( 3 )\ndt = ndarrayMinDataType( -3 )\ndt = ndarrayMinDataType( '-3' )\n","ndarrayNextDataType":"var out = ndarrayNextDataType( 'float32' )\n","ndarrayOrders":"var out = ndarrayOrders()\n","ndarrayPromotionRules":"var out = ndarrayPromotionRules( 'float32', 'int32' )\n","ndarraySafeCasts":"var out = ndarraySafeCasts( 'float32' )\n","ndarraySameKindCasts":"var out = ndarraySameKindCasts( 'float32' )\n","NIGHTINGALES_ROSE":"var data = NIGHTINGALES_ROSE()\n","NINF":"NINF\n","NODE_VERSION":"NODE_VERSION\n","none":"var arr = [ 0, 0, 0, 0, 0 ];\nvar bool = none( arr )\n","noneBy":"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, 3, 4 ];\nvar bool = noneBy( arr, negative )\n","noneByAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n","noneByRight":"function positive( v ) { return ( v > 0 ); };\nvar arr = [ -1, -2, -3, -4 ];\nvar bool = noneByRight( arr, positive )\n","noneByRightAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n","nonEnumerableProperties":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar props = nonEnumerableProperties( obj )\n","nonEnumerablePropertiesIn":"var props = nonEnumerablePropertiesIn( [] )\n","nonEnumerablePropertyNames":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = nonEnumerablePropertyNames( obj )\n","nonEnumerablePropertyNamesIn":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = nonEnumerablePropertyNamesIn( obj )\n","nonEnumerablePropertySymbols":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = nonEnumerablePropertySymbols( obj )\n","nonEnumerablePropertySymbolsIn":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = nonEnumerablePropertySymbolsIn( obj )\n","noop":"noop();\n","now":"var ts = now()\n","NUM_CPUS":"NUM_CPUS\n","Number":"var v = new Number( 5 )\n","objectEntries":"var obj = { 'beep': 'boop', 'foo': 'bar' };\nvar entries = objectEntries( obj )\n","objectEntriesIn":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar entries = objectEntriesIn( obj )\n","objectFromEntries":"var entries = [ [ 'beep', 'boop' ], [ 'foo', 'bar' ] ];\nvar obj = objectFromEntries( entries )\n","objectInverse":"\n// Basic usage:\nvar obj = { 'a': 'beep', 'b': 'boop' };\nvar out = objectInverse( obj )\n\n// Duplicate values:\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverse( obj )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverse( obj, { 'duplicates': false } )\n","objectInverseBy":"\n// Basic usage:\nfunction transform( key, value ) { return key + value; };\nvar obj = { 'a': 'beep', 'b': 'boop' };\nvar out = objectInverseBy( obj, transform )\n\n// Duplicate values:\nfunction transform( key, value ) { return value; };\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverseBy( obj, transform )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverseBy( obj, { 'duplicates': false }, transform )\n","objectKeys":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = objectKeys( obj )\n","objectValues":"var obj = { 'beep': 'boop', 'foo': 'bar' };\nvar vals = objectValues( obj )\n","objectValuesIn":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar values = objectValuesIn( obj )\n","omit":"var obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = omit( obj1, 'b' )\n","omitBy":"function predicate( key, value ) { return ( value > 1 ); };\nvar obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = omitBy( obj1, predicate )\n","openURL":"var out = openURL( 'https://google.com' );\n","PACE_BOSTON_HOUSE_PRICES":"var data = PACE_BOSTON_HOUSE_PRICES()\n","pad":"\n// Standard usage:\nvar out = pad( 'a', 5 )\n\n// Left pad:\nout = pad( 'a', 10, { 'lpad': 'b' })\n\n// Right pad:\nout = pad( 'a', 12, { 'rpad': 'b' })\n\n// Center an input string:\nvar opts = { 'lpad': 'a', 'rpad': 'c' };\nout = pad( 'b', 11, opts )\n\n// Left center:\nopts.centerRight = false;\nout = pad( 'b', 10, opts )\n\n// Right center:\nopts.centerRight = true;\nout = pad( 'b', 10, opts )\n\n// Output string always length `len`:\nopts = { 'lpad': 'boop', 'rpad': 'woot' };\nout = pad( 'beep', 10, opts )\n\n// Pad right, trim right:\nout = pad( 'beep', 2 )\n\n// Pad left, trim left:\nopts = { 'lpad': 'b' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both:\nopts = { 'lpad': '@', 'rpad': '!' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both starting from left:\nout = pad( 'abcdef', 3, opts )\n\n// Pad both, trim both starting from right:\nopts.centerRight = true;\nout = pad( 'abcdef', 3, opts )\n","papply":"function add( x, y ) { return x + y; };\nvar add2 = papply( add, 2 );\nvar sum = add2( 3 )\n","papplyRight":"function say( text, name ) { return text + ', ' + name + '.'; };\nvar toGrace = papplyRight( say, 'Grace Hopper' );\nvar str = toGrace( 'Hello' )\nstr = toGrace( 'Thank you' )\n","parallel":"function done( error ) { if ( error ) { throw error; } };\nvar files = [ './a.js', './b.js' ];\nparallel( files, done );\n\n// Specify the number of workers:\nvar opts = { 'workers': 8 };\nparallel( files, opts, done );\n","parseJSON":"var obj = parseJSON( '{\"beep\":\"boop\"}' )\n\n// Provide a reviver:\nfunction reviver( key, value ) {\n if ( key === '' ) { return value; }\n if ( key === 'beep' ) { return value; }\n};\nvar str = '{\"beep\":\"boop\",\"a\":\"b\"}';\nvar out = parseJSON( str, reviver )\n","PATH_DELIMITER":"PATH_DELIMITER\n\n// POSIX environment:\nvar path = '/usr/bin:/bin:/usr/sbin';\nvar parts = path.split( PATH_DELIMITER )\n\n// Windows environment:\npath = 'C:\\\\Windows\\\\system32;C:\\\\Windows';\nparts = path.split( PATH_DELIMITER )\n","PATH_DELIMITER_POSIX":"PATH_DELIMITER_POSIX\nvar PATH = '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin';\nvar paths = PATH.split( PATH_DELIMITER_POSIX )\n","PATH_DELIMITER_WIN32":"PATH_DELIMITER_WIN32\nvar PATH = 'C:\\\\Windows\\\\system32;C:\\\\Windows;C:\\\\Program Files\\\\node\\\\';\nvar paths = PATH.split( PATH_DELIMITER_WIN32 )\n","PATH_SEP":"PATH_SEP\n\n// Windows environment:\nvar parts = 'foo\\\\bar\\\\baz'.split( PATH_SEP )\n\n// POSIX environment:\nparts = 'foo/bar/baz'.split( PATH_SEP )\n","PATH_SEP_POSIX":"PATH_SEP_POSIX\nvar parts = 'foo/bar/baz'.split( PATH_SEP_POSIX )\n","PATH_SEP_WIN32":"PATH_SEP_WIN32\nvar parts = 'foo\\\\bar\\\\baz'.split( PATH_SEP_WIN32 )\n","pcorrtest":"var rho = 0.5;\nvar x = new Array( 300 );\nvar y = new Array( 300 );\nfor ( var i = 0; i < 300; i++ ) {\n x[ i ] = base.random.normal( 0.0, 1.0 );\n y[ i ] = ( rho * x[ i ] ) + base.random.normal( 0.0,\n base.sqrt( 1.0 - (rho*rho) ) );\n}\nvar out = pcorrtest( x, y )\n\n// Print output:\nvar table = out.print()\n","percentEncode":"var out = percentEncode( '☃' )\n","PHI":"PHI\n","PI":"PI\n","PI_SQUARED":"PI_SQUARED\n","pick":"var obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = pick( obj1, 'b' )\n","pickBy":"function predicate( key, value ) {\n return ( value > 1 );\n};\nvar obj1 = { 'a': 1, 'b': 2 };\nvar obj2 = pickBy( obj1, predicate )\n","PINF":"PINF\n","pkg2alias":"var v = pkg2alias( '@stdlib/math/base/special/sin' )\n","pkg2related":"var v = pkg2related( '@stdlib/math/base/special/sin' )\n","PLATFORM":"PLATFORM\n","plot":"var plot = plot()\n\n// Provide plot data at instantiation:\nvar x = [[0.10, 0.20, 0.30]];\nvar y = [[0.52, 0.79, 0.64]];\nplot = plot( x, y )\n","Plot":"var plot = Plot()\n\n// Provide plot data at instantiation:\nvar x = [[0.10, 0.20, 0.30]];\nvar y = [[0.52, 0.79, 0.64]];\nplot = Plot( x, y )\n","pluck":"var arr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nvar out = pluck( arr, 'a' )\narr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nout = pluck( arr, 'a', { 'copy': false } )\nvar bool = ( arr[ 0 ] === out[ 0 ] )\n","pop":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar out = pop( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = pop( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = pop( arr )\n","prepend":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = prepend( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = prepend( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = prepend( arr, [ 2.0, 3.0 ] )\n","properties":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = properties( obj )\n","propertiesIn":"var props = propertiesIn( [] )\n","propertyDescriptor":"var obj = { 'a': 'b' };\nvar desc = propertyDescriptor( obj, 'a' )\n","propertyDescriptorIn":"var obj = { 'a': 'b' };\nvar desc = propertyDescriptorIn( obj, 'a' )\n","propertyDescriptors":"var obj = { 'a': 'b' };\nvar desc = propertyDescriptors( obj )\n","propertyDescriptorsIn":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar desc = propertyDescriptorsIn( obj )\n","propertyNames":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = propertyNames( obj )\n","propertyNamesIn":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar keys = propertyNamesIn( obj )\n","propertySymbols":"var s = propertySymbols( {} )\n","propertySymbolsIn":"var s = propertySymbolsIn( [] )\n","Proxy":"function get( obj, prop ) { return obj[ prop ] * 2.0 };\nvar h = { 'get': get };\nvar p = new Proxy( {}, h );\np.a = 3.14;\np.a\n","push":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = push( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = push( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 0 };\narr = push( arr, 1.0, 2.0 )\n","quarterOfYear":"var q = quarterOfYear( new Date() )\nq = quarterOfYear( 4 )\nq = quarterOfYear( 'June' )\n\n// Other ways to supply month:\nq = quarterOfYear( 'April' )\nq = quarterOfYear( 'apr' )\n","random.iterators.arcsine":"var it = random.iterators.arcsine( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.bernoulli":"var it = random.iterators.bernoulli( 0.3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.beta":"var it = random.iterators.beta( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.betaprime":"var it = random.iterators.betaprime( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.binomial":"var it = random.iterators.binomial( 10, 0.3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.boxMuller":"var it = random.iterators.boxMuller();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.cauchy":"var it = random.iterators.cauchy( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.chi":"var it = random.iterators.chi( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.chisquare":"var it = random.iterators.chisquare( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.cosine":"var it = random.iterators.cosine( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.discreteUniform":"var it = random.iterators.discreteUniform( 0, 3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.erlang":"var it = random.iterators.erlang( 1, 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.exponential":"var it = random.iterators.exponential( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.f":"var it = random.iterators.f( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.frechet":"var it = random.iterators.frechet( 1.0, 1.0, 0.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.gamma":"var it = random.iterators.gamma( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.geometric":"var it = random.iterators.geometric( 0.3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.gumbel":"var it = random.iterators.gumbel( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.hypergeometric":"var it = random.iterators.hypergeometric( 20, 10, 7 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.improvedZiggurat":"var it = random.iterators.improvedZiggurat();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.invgamma":"var it = random.iterators.invgamma( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.kumaraswamy":"var it = random.iterators.kumaraswamy( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.laplace":"var it = random.iterators.laplace( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.levy":"var it = random.iterators.levy( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.logistic":"var it = random.iterators.logistic( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.lognormal":"var it = random.iterators.lognormal( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.minstd":"var it = random.iterators.minstd();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.minstdShuffle":"var it = random.iterators.minstdShuffle();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.mt19937":"var it = random.iterators.mt19937();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.negativeBinomial":"var it = random.iterators.negativeBinomial( 10, 0.3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.normal":"var it = random.iterators.normal( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.pareto1":"var it = random.iterators.pareto1( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.poisson":"var it = random.iterators.poisson( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.randi":"var it = random.iterators.randi();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.randn":"var it = random.iterators.randn();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.randu":"var it = random.iterators.randu();\nvar r = it.next().value\nr = it.next().value\n","random.iterators.rayleigh":"var it = random.iterators.rayleigh( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.t":"var it = random.iterators.t( 1.5 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.triangular":"var it = random.iterators.triangular( 0.0, 1.0, 0.3 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.uniform":"var it = random.iterators.uniform( 0.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.iterators.weibull":"var it = random.iterators.weibull( 1.0, 1.0 );\nvar r = it.next().value\nr = it.next().value\n","random.streams.arcsine":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.arcsine( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.bernoulli":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.bernoulli( 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.beta":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.beta( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.betaprime":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.betaprime( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.binomial":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.binomial( 20, 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.boxMuller":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.boxMuller( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.cauchy":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.cauchy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.chi":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.chi( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.chisquare":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.chisquare( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.cosine":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.cosine( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.discreteUniform":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.discreteUniform( 2, 5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.erlang":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.erlang( 2, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.exponential":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.exponential( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.f":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.f( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.gamma":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.gamma( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.geometric":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.geometric( 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.gumbel":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.gumbel( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.improvedZiggurat":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.improvedZiggurat( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.invgamma":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.invgamma( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.kumaraswamy":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.kumaraswamy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.laplace":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.laplace( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.levy":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.levy( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.logistic":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.logistic( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.lognormal":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.lognormal( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.minstd":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.minstd( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.minstdShuffle":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.minstdShuffle( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.mt19937":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.mt19937( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.negativeBinomial":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.negativeBinomial( 20.0, 0.5, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.normal":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.normal( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.pareto1":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.pareto1( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.poisson":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.poisson( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.randi":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randi( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.randn":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randn( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.randu":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.randu( opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.rayleigh":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.rayleigh( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.t":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.t( 3.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.uniform":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.uniform( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","random.streams.weibull":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar opts = { 'iter': 10 };\nvar s = random.streams.weibull( 2.0, 5.0, opts );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","ranks":"var arr = [ 1.1, 2.0, 3.5, 0.0, 2.4 ] ;\nvar out = ranks( arr )\n\n// Ties are averaged:\narr = [ 2, 2, 1, 4, 3 ];\nout = ranks( arr )\n\n// Missing values are placed last:\narr = [ null, 2, 2, 1, 4, 3, NaN, NaN ];\nout = ranks( arr )\n","RE_BASENAME":"var base = RE_BASENAME.exec( '/foo/bar/index.js' )[ 1 ]\n","RE_BASENAME_POSIX":"var base = RE_BASENAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '.' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '' )[ 1 ]\n","RE_BASENAME_WINDOWS":"var base = RE_BASENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\\\bar\\\\file' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '.' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '' )[ 1 ]\n","RE_COLOR_HEXADECIMAL":"var bool = RE_COLOR_HEXADECIMAL.test( 'ffffff' )\nbool = RE_COLOR_HEXADECIMAL.test( '000' )\nbool = RE_COLOR_HEXADECIMAL.test( 'beep' )\n","RE_DECIMAL_NUMBER":"var bool = RE_DECIMAL_NUMBER.test( '1.234' )\nbool = RE_DECIMAL_NUMBER.test( '-1.234' )\nbool = RE_DECIMAL_NUMBER.test( '0.0' )\nbool = RE_DECIMAL_NUMBER.test( '.0' )\nbool = RE_DECIMAL_NUMBER.test( '0' )\nbool = RE_DECIMAL_NUMBER.test( 'beep' )\n\n// Create a RegExp to capture all decimal numbers:\nvar re = new RegExp( RE_DECIMAL_NUMBER.source, 'g' );\nvar str = '1.234 5.6, 7.8';\nvar out = str.match( re )\n","RE_DIRNAME":"var dir = RE_DIRNAME.exec( '/foo/bar/index.js' )[ 1 ]\n","RE_DIRNAME_POSIX":"var dir = RE_DIRNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '.' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '' )[ 1 ]\n","RE_DIRNAME_WINDOWS":"var dir = RE_DIRNAME_WINDOWS.exec( 'foo\\\\bar\\\\index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '' )[ 1 ]\n","RE_EOL":"var bool = RE_EOL.test( '\\n' )\nbool = RE_EOL.test( '\\r\\n' )\nbool = RE_EOL.test( '\\\\r\\\\n' )\n","RE_EXTENDED_LENGTH_PATH":"var path = '\\\\\\\\?\\\\C:\\\\foo\\\\bar';\nvar bool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '\\\\\\\\?\\\\UNC\\\\server\\\\share';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = 'C:\\\\foo\\\\bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/c/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\n","RE_EXTNAME":"var dir = RE_EXTNAME.exec( '/foo/bar/index.js' )[ 1 ]\n","RE_EXTNAME_POSIX":"var ext = RE_EXTNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '.' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '' )[ 1 ]\n","RE_EXTNAME_WINDOWS":"var ext = RE_EXTNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'beep\\\\boop.' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '' )[ 1 ]\n","RE_FILENAME":"var f = '/foo/bar/index.js';\nvar parts = RE_FILENAME.exec( f ).slice()\n","RE_FILENAME_POSIX":"var parts = RE_FILENAME_POSIX.exec( '/foo/bar/index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( './foo/bar/.gitignore' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'foo/file.pdf' ).slice()\nparts = RE_FILENAME_POSIX.exec( '/foo/bar/file' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( '.' ).slice()\nparts = RE_FILENAME_POSIX.exec( './' ).slice()\nparts = RE_FILENAME_POSIX.exec( '' ).slice()\n","RE_FILENAME_WINDOWS":"var parts = RE_FILENAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\.gitignore' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'foo\\\\file.pdf' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '.' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( './' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '' ).slice()\n","RE_FUNCTION_NAME":"function beep() { return 'boop'; };\nvar name = RE_FUNCTION_NAME.exec( beep.toString() )[ 1 ]\nname = RE_FUNCTION_NAME.exec( function () {} )[ 1 ]\n","RE_NATIVE_FUNCTION":"var bool = RE_NATIVE_FUNCTION.test( Date.toString() )\nbool = RE_NATIVE_FUNCTION.test( (function noop() {}).toString() )\n","RE_REGEXP":"var bool = RE_REGEXP.test( '/^beep$/' )\nbool = RE_REGEXP.test( '/boop' )\n\n// Escape regular expression strings:\nbool = RE_REGEXP.test( '/^\\/([^\\/]+)\\/(.*)$/' )\nbool = RE_REGEXP.test( '/^\\\\/([^\\\\/]+)\\\\/(.*)$/' )\n","RE_UNC_PATH":"var path = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:b';\nvar bool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz::b';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\\\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = 'beep boop \\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz::';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:b:c';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '//server/share';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = 'foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = './foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/../bar';\nbool = RE_UNC_PATH.test( path )\n","RE_UTF16_SURROGATE_PAIR":"var bool = RE_UTF16_SURROGATE_PAIR.test( 'abc\\uD800\\uDC00def' )\nbool = RE_UTF16_SURROGATE_PAIR.test( 'abcdef' )\n","RE_UTF16_UNPAIRED_SURROGATE":"var bool = RE_UTF16_UNPAIRED_SURROGATE.test( 'abc' )\nbool = RE_UTF16_UNPAIRED_SURROGATE.test( '\\uD800' )\n","RE_WHITESPACE":"var bool = RE_WHITESPACE.test( '\\n' )\nbool = RE_WHITESPACE.test( ' ' )\nbool = RE_WHITESPACE.test( 'a' )\n","readDir":"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadDir( './beep/boop', onRead );\n","readFile":"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadFile( './beep/boop.js', onRead );\n","readFileList":"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nvar filepaths = [ './beep/boop.txt', './foo/bar.txt' ];\nreadFileList( filepaths, onRead );\n","readJSON":"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadJSON( './beep/boop.json', onRead );\n","readWASM":"function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadWASM( './beep/boop.wasm', onRead );\n","real":"var z = new Complex128( 5.0, 3.0 );\nvar re = real( z )\n","realmax":"var m = realmax( 'float16' )\nm = realmax( 'float32' )\n","realmin":"var m = realmin( 'float16' )\nm = realmin( 'float32' )\n","reduce":"function sum( acc, v ) { return acc + v; };\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = reduce( arr, 0, sum )\n","reduceAsync":"\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'series': false };\nvar arr = [ 3000, 2500, 1000 ];\nvar acc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n","reduceRight":"function sum( acc, v ) {\n console.log( '%s: %d', acc, v );\n return acc + v;\n};\nvar arr = [ 1.0, 2.0, 3.0 ];\nvar out = reduceRight( arr, 0, sum );\nout\n","reduceRightAsync":"\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nvar opts = { 'series': false };\nvar arr = [ 1000, 2500, 3000 ];\nvar acc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n","reFromString":"var re = reFromString( '/beep/' )\nre = reFromString( '/beep' )\n","reim":"var z = new Complex128( 5.0, 3.0 );\nvar out = reim( z )\n","removeFirst":"var out = removeFirst( 'beep' )\nout = removeFirst( 'Boop' )\n","removeLast":"var out = removeLast( 'beep' )\nout = removeLast( 'Boop' )\n","removePunctuation":"var str = 'Sun Tzu said: \"A leader leads by example not by force.\"';\nvar out = removePunctuation( str )\nstr = 'This function removes these characters: `{}[]:,!/<>().;~|?\\'\"';\nout = removePunctuation( str )\n","removeUTF8BOM":"var out = removeUTF8BOM( '\\ufeffbeep' )\n","removeWords":"var out = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ] )\n\n// Case-insensitive:\nout = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ], true )\n","rename":"function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nrename( './beep/boop.txt', './beep/foo.txt', done );\n","reorderArguments":"function foo( a, b, c ) { return [ a, b, c ]; };\nvar bar = reorderArguments( foo, [ 2, 0, 1 ] );\nvar out = bar( 1, 2, 3 )\n","repeat":"var out = repeat( 'a', 5 )\nout = repeat( '', 100 )\nout = repeat( 'beep', 0 )\n","replace":"\n// Standard usage:\nvar out = replace( 'beep', 'e', 'o' )\n\n// Replacer function:\nfunction replacer( match, p1 ) { return '/'+p1+'/'; };\nvar str = 'Oranges and lemons';\nout = replace( str, /([^\\s]+)/gi, replacer )\n\n// Replace only first match:\nout = replace( 'beep', /e/, 'o' )\n","rescape":"var str = rescape( '[A-Z]*' )\n","resolveParentPath":"function onPath( error, path ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( path );\n }\n};\nresolveParentPath( 'package.json', onPath );\n","reverseArguments":"function foo( a, b, c ) { return [ a, b, c ]; };\nvar bar = reverseArguments( foo );\nvar out = bar( 1, 2, 3 )\n","reverseString":"var out = reverseString( 'foo' )\nout = reverseString( 'abcdef' )\n","reviveBasePRNG":"var str = JSON.stringify( base.random.mt19937 );\nvar r = parseJSON( str, reviveBasePRNG )\n","reviveBuffer":"var str = '{\"type\":\"Buffer\",\"data\":[5,3]}';\nvar buf = parseJSON( str, reviveBuffer )\n","reviveComplex":"var str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex )\n","reviveComplex64":"var str = '{\"type\":\"Complex64\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex64 )\n","reviveComplex128":"var str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nvar z = parseJSON( str, reviveComplex128 )\n","reviveError":"var str = '{\"type\":\"TypeError\",\"message\":\"beep\"}';\nvar err = JSON.parse( str, reviveError )\n","reviveTypedArray":"var str = '{\"type\":\"Float64Array\",\"data\":[5,3]}';\nvar arr = parseJSON( str, reviveTypedArray )\n","rpad":"var out = rpad( 'a', 5 )\nout = rpad( 'beep', 10, 'p' )\nout = rpad( 'beep', 12, 'boop' )\n","rtrim":"var out = rtrim( ' \\t\\t\\n Beep \\r\\n\\t ' )\n","safeintmax":"var m = safeintmax( 'float16' )\nm = safeintmax( 'float32' )\n","safeintmin":"var m = safeintmin( 'float16' )\nm = safeintmin( 'float32' )\n","sample":"var out = sample( 'abc' )\nout = sample( [ 3, 6, 9 ] )\nvar bool = ( out.length === 3 )\nout = sample( [ 3, null, NaN, 'abc', function(){} ] )\n\n// Set sample size:\nout = sample( [ 3, 6, 9 ], { 'size': 10 })\nout = sample( [ 0, 1 ], { 'size': 20 })\n\n// Draw without replacement:\nout = sample( [ 1, 2, 3, 4, 5, 6 ], { 'replace': false, 'size': 3 })\nout = sample( [ 0, 1 ], { 'replace': false })\n\n// Assigning non-uniform element probabilities:\nvar x = [ 1, 2, 3, 4, 5, 6 ];\nvar probs = [ 0.1, 0.1, 0.1, 0.1, 0.1, 0.5 ];\nout = sample( x, { 'probs': probs })\nout = sample( x, { 'probs': probs, 'size': 3, 'replace': false })\n","SAVOY_STOPWORDS_FIN":"var list = SAVOY_STOPWORDS_FIN()\n","SAVOY_STOPWORDS_FR":"var list = SAVOY_STOPWORDS_FR()\n","SAVOY_STOPWORDS_GER":"var list = SAVOY_STOPWORDS_GER()\n","SAVOY_STOPWORDS_IT":"var list = SAVOY_STOPWORDS_IT()\n","SAVOY_STOPWORDS_POR":"var list = SAVOY_STOPWORDS_POR()\n","SAVOY_STOPWORDS_SP":"var list = SAVOY_STOPWORDS_SP()\n","SAVOY_STOPWORDS_SWE":"var list = SAVOY_STOPWORDS_SWE()\n","SECONDS_IN_DAY":"var days = 3.14;\nvar secs = days * SECONDS_IN_DAY\n","SECONDS_IN_HOUR":"var hrs = 3.14;\nvar secs = hrs * SECONDS_IN_HOUR\n","SECONDS_IN_MINUTE":"var mins = 3.14;\nvar secs = mins * SECONDS_IN_MINUTE\n","SECONDS_IN_WEEK":"var wks = 3.14;\nvar secs = wks * SECONDS_IN_WEEK\n","secondsInMonth":"var num = secondsInMonth()\nnum = secondsInMonth( 2 )\nnum = secondsInMonth( 2, 2016 )\nnum = secondsInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = secondsInMonth( 'feb', 2016 )\nnum = secondsInMonth( 'february', 2016 )\n","secondsInYear":"var num = secondsInYear()\nnum = secondsInYear( 2016 )\nnum = secondsInYear( 2017 )\n","setConfigurableReadOnly":"var obj = {};\nsetConfigurableReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n","setConfigurableReadOnlyAccessor":"var obj = {};\nfunction getter() { return 'bar'; };\nsetConfigurableReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n","setConfigurableReadWriteAccessor":"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetConfigurableReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n","setConfigurableWriteOnlyAccessor":"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetConfigurableWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n","setMemoizedReadOnly":"var obj = {};\nfunction foo() { return 'bar'; };\nsetMemoizedReadOnly( obj, 'foo', foo );\nobj.foo\n","setNonEnumerableProperty":"var obj = {};\nsetNonEnumerableProperty( obj, 'foo', 'bar' );\nobj.foo\nobjectKeys( obj )\n","setNonEnumerableReadOnly":"var obj = {};\nsetNonEnumerableReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n","setNonEnumerableReadOnlyAccessor":"var obj = {};\nfunction getter() { return 'bar'; };\nsetNonEnumerableReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n","setNonEnumerableReadWriteAccessor":"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n","setNonEnumerableWriteOnlyAccessor":"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n","setReadOnly":"var obj = {};\nsetReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n","setReadOnlyAccessor":"var obj = {};\nfunction getter() { return 'bar'; };\nsetReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n","setReadWriteAccessor":"var obj = {};\nvar name = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n","setWriteOnlyAccessor":"var obj = {};\nvar val = '';\nfunction setter( v ) { val = v; };\nsetWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n","SharedArrayBuffer":"\n// Assuming an environment supports SharedArrayBuffers...\nvar buf = new SharedArrayBuffer( 5 )\n","shift":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nvar out = shift( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = shift( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = shift( arr )\n","shuffle":"var data = [ 1, 2, 3 ];\nvar out = shuffle( data )\nout = shuffle( data, { 'copy': 'none' });\nvar bool = ( data === out )\n","sizeOf":"var s = sizeOf( 'int8' )\ns = sizeOf( 'uint32' )\n","some":"var arr = [ 0, 0, 1, 2, 3 ];\nvar bool = some( arr, 3 )\n","someBy":"function negative( v ) { return ( v < 0 ); };\nvar arr = [ 1, 2, -3, 4, -1 ];\nvar bool = someBy( arr, 2, negative )\n","someByAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n","someByRight":"function negative( v ) { return ( v < 0 ); };\nvar arr = [ -1, 1, -2, 3, 4 ];\nvar bool = someByRight( arr, 2, negative )\n","someByRightAsync":"\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nvar opts = { 'series': true };\nvar arr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n","SOTU":"var out = SOTU()\n\n// Retrieve addresses by one or more Presidents...\nvar opts = { 'name': 'Barack Obama' };\nout = SOTU( opts )\n\n// Retrieve addresses by one or more political parties...\nopts = { 'party': [ 'Democratic', 'Federalist' ] };\nout = SOTU( opts )\n\n// Retrieve addresses from one or more years...\nopts = { 'year': [ 2008, 2009, 2011 ] };\nout = SOTU( opts )\n\n// Retrieve addresses from a range of consecutive years...\nopts = { 'range': [ 2008, 2016 ] }\nout = SOTU( opts )\n","SPACHE_REVISED":"var list = SPACHE_REVISED()\n","SPAM_ASSASSIN":"var data = SPAM_ASSASSIN()\n","SparklineBase":"var sparkline = new SparklineBase()\n\n// Provide sparkline data at instantiation:\nvar data = [ 1, 2, 3 ];\nsparkline = new SparklineBase( data )\n","sparsearray2iterator":"var it = sparsearray2iterator( [ 1, , 3, 4 ] );\nvar v = it.next().value\nv = it.next().value\n","sparsearray2iteratorRight":"var it = sparsearray2iteratorRight( [ 1, 2, , 4 ] );\nvar v = it.next().value\nv = it.next().value\n","splitStream":"var s = splitStream();\ns.write( 'a\\nb\\nc' );\ns.end();\n","SQRT_EPS":"SQRT_EPS\n","SQRT_HALF":"SQRT_HALF\n","SQRT_HALF_PI":"SQRT_HALF_PI\n","SQRT_PHI":"SQRT_PHI\n","SQRT_PI":"SQRT_PI\n","SQRT_THREE":"SQRT_THREE\n","SQRT_TWO":"SQRT_TWO\n","SQRT_TWO_PI":"SQRT_TWO_PI\n","Stack":"var s = Stack();\ns.push( 'foo' ).push( 'bar' );\ns.length\ns.pop()\ns.length\ns.pop()\ns.length\n","startcase":"var out = startcase( 'beep boop' )\n","startsWith":"var bool = startsWith( 'Beep', 'Be' )\nbool = startsWith( 'Beep', 'ep' )\nbool = startsWith( 'Beep', 'ee', 1 )\nbool = startsWith( 'Beep', 'ee', -3 )\nbool = startsWith( 'Beep', '' )\n","STOPWORDS_EN":"var list = STOPWORDS_EN()\n","stridedarray2iterator":"var it = stridedarray2iterator( 2, [ 1, 2, 3, 4 ], -2, 3 );\nvar v = it.next().value\nv = it.next().value\n","stridedArrayStream":"function fcn( chunk ) { console.log( chunk.toString() ); };\nvar s = stridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );\nvar o = inspectSinkStream( fcn );\ns.pipe( o );\n","string2buffer":"var b = string2buffer( 'beep boop' )\nb = string2buffer( '7468697320697320612074c3a97374', 'hex' );\nb.toString()\n","sub2ind":"var d = [ 3, 3, 3 ];\nvar idx = sub2ind( d, 1, 2, 2 )\n","SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK":"var data = SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK()\n","SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK":"var data = SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK()\n","Symbol":"var s = ( Symbol ) ? Symbol( 'beep' ) : null\n","tabulate":"var collection = [ 'beep', 'boop', 'foo', 'beep' ];\nvar out = tabulate( collection )\n","tabulateBy":"function indicator( value ) { return value[ 0 ]; };\nvar collection = [ 'beep', 'boop', 'foo', 'beep' ];\nvar out = tabulateBy( collection, indicator )\n","tabulateByAsync":"\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'limit': 2 };\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nvar opts = { 'series': true };\nvar arr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n","tic":"var t = tic()\n","timeit":"var code = 'var x = Math.pow( Math.random(), 3 );';\ncode += 'if ( x !== x ) {';\ncode += 'throw new Error( \\'Something went wrong.\\' );';\ncode += '}';\nfunction done( error, results ) {\n if ( error ) {\n throw error;\n }\n console.dir( results );\n};\ntimeit( code, done )\n","tmpdir":"var dir = tmpdir()\n","toc":"var start = tic();\nvar delta = toc( start )\n","tokenize":"var out = tokenize( 'Hello Mrs. Maple, could you call me back?' )\nout = tokenize( 'Hello World!', true )\n","transformStream":"var s = transformStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n","trim":"var out = trim( ' \\t\\t\\n Beep \\r\\n\\t ' )\n","trycatch":"function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nvar z = trycatch( x, -1.0 )\n","trycatchAsync":"function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n // process error...\n }\n console.log( result );\n};\ntrycatchAsync( x, 'boop', done )\n","tryFunction":"function fcn() { throw new Error( 'beep boop' ); };\nvar f = tryFunction( fcn );\nvar out = f();\nout.message\n","tryRequire":"var out = tryRequire( '_unknown_module_id_' )\n","trythen":"function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nfunction y() {\n return -1.0;\n};\nvar z = trythen( x, y )\n","trythenAsync":"function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ntrythenAsync( x, y, done )\n","ttest":"\n// One-sample t-test:\nvar rnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 5776 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nvar out = ttest( x )\n\n// Paired t-test:\nrnorm = base.random.normal.factory( 1.0, 2.0, { 'seed': 786 });\nx = new Array( 100 );\nvar y = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n y[ i ] = rnorm();\n}\nout = ttest( x, y )\n\n// Print formatted output:\nvar table = out.print()\n\n// Choose custom significance level:\narr = [ 2, 4, 3, 1, 0 ];\nout = ttest( arr, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\nvar arr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'alternative': 'less' });\ntable = out.print()\nout = ttest( arr, { 'alternative': 'greater' });\ntable = out.print()\n","ttest2":"\n// Student's sleep data:\nvar x = [ 0.7, -1.6, -0.2, -1.2, -0.1, 3.4, 3.7, 0.8, 0.0, 2.0 ];\nvar y = [ 1.9, 0.8, 1.1, 0.1, -0.1, 4.4, 5.5, 1.6, 4.6, 3.4 ];\nvar out = ttest2( x, y )\n\n// Print table output:\nvar table = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ttest2( x, y, { 'alpha': 0.1 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ttest2( x, y, { 'alternative': 'less' });\ntable = out.print()\nout = ttest2( x, y, { 'alternative': 'greater' });\ntable = out.print()\n\n// Run tests with equal variances assumption:\nx = [ 2, 3, 1, 4 ];\ny = [ 1, 2, 3, 1, 2, 5, 3, 4 ];\nout = ttest2( x, y, { 'variance': 'equal' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nvar rnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 3.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 1.0, 3.0 );\n}\nout = ttest2( x, y, { 'difference': 1.0, 'variance': 'equal' })\n","TWO_PI":"TWO_PI\n","typedarray":"var arr = typedarray()\narr = typedarray( 'float32' )\n","typedarray2json":"var arr = new Float64Array( 2 );\narr[ 0 ] = 5.0;\narr[ 1 ] = 3.0;\nvar json = typedarray2json( arr )\n","typedarrayComplexCtors":"var ctor = typedarrayComplexCtors( 'complex64' )\nctor = typedarrayComplexCtors( 'float32' )\n","typedarrayComplexDataTypes":"var out = typedarrayComplexDataTypes()\n","typedarrayCtors":"var ctor = typedarrayCtors( 'float64' )\nctor = typedarrayCtors( 'float' )\n","typedarrayDataTypes":"var out = typedarrayDataTypes()\n","typedarraypool":"var arr = typedarraypool()\narr = typedarraypool( 'float32' )\n","typemax":"var m = typemax( 'int8' )\nm = typemax( 'uint32' )\n","typemin":"var m = typemin( 'int8' )\nm = typemin( 'uint32' )\n","typeOf":"\n// Built-ins:\nvar t = typeOf( 'a' )\nt = typeOf( 5 )\nt = typeOf( NaN )\nt = typeOf( true )\nt = typeOf( false )\nt = typeOf( null )\nt = typeOf( undefined )\nt = typeOf( [] )\nt = typeOf( {} )\nt = typeOf( function noop() {} )\nt = typeOf( Symbol( 'beep' ) )\nt = typeOf( /.+/ )\nt = typeOf( new String( 'beep' ) )\nt = typeOf( new Number( 5 ) )\nt = typeOf( new Boolean( false ) )\nt = typeOf( new Array() )\nt = typeOf( new Object() )\nt = typeOf( new Int8Array( 10 ) )\nt = typeOf( new Uint8Array( 10 ) )\nt = typeOf( new Uint8ClampedArray( 10 ) )\nt = typeOf( new Int16Array( 10 ) )\nt = typeOf( new Uint16Array( 10 ) )\nt = typeOf( new Int32Array( 10 ) )\nt = typeOf( new Uint32Array( 10 ) )\nt = typeOf( new Float32Array( 10 ) )\nt = typeOf( new Float64Array( 10 ) )\nt = typeOf( new ArrayBuffer( 10 ) )\nt = typeOf( new Date() )\nt = typeOf( new RegExp( '.+' ) )\nt = typeOf( new Map() )\nt = typeOf( new Set() )\nt = typeOf( new WeakMap() )\nt = typeOf( new WeakSet() )\nt = typeOf( new Error( 'beep' ) )\nt = typeOf( new TypeError( 'beep' ) )\nt = typeOf( new SyntaxError( 'beep' ) )\nt = typeOf( new ReferenceError( 'beep' ) )\nt = typeOf( new URIError( 'beep' ) )\nt = typeOf( new RangeError( 'beep' ) )\nt = typeOf( new EvalError( 'beep' ) )\nt = typeOf( Math )\nt = typeOf( JSON )\n\n// Arguments object:\nfunction beep() { return arguments; };\nt = typeOf( beep() )\n\n// Node.js Buffer object:\nt = typeOf( new Buffer( 10 ) )\n\n// Custom constructor:\nfunction Person() { return this };\nt = typeOf( new Person() )\n\n// Anonymous constructor:\nvar Foo = function () { return this; };\nt = typeOf( new Foo() )\n","UINT8_MAX":"UINT8_MAX\n","UINT8_NUM_BYTES":"UINT8_NUM_BYTES\n","Uint8Array":"var arr = new Uint8Array()\n","Uint8ClampedArray":"var arr = new Uint8ClampedArray()\n","UINT16_MAX":"UINT16_MAX\n","UINT16_NUM_BYTES":"UINT16_NUM_BYTES\n","Uint16Array":"var arr = new Uint16Array()\n","UINT32_MAX":"UINT32_MAX\n","UINT32_NUM_BYTES":"UINT32_NUM_BYTES\n","Uint32Array":"var arr = new Uint32Array()\n","umask":"var mask = umask()\nmask = umask( { 'symbolic': true } )\n","uncapitalize":"var out = uncapitalize( 'Beep' )\nout = uncapitalize( 'bOOp' )\n","uncapitalizeKeys":"var obj = { 'AA': 1, 'BB': 2 };\nvar out = uncapitalizeKeys( obj )\n","uncurry":"function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nvar fcn = uncurry( addX );\nvar sum = fcn( 2, 3 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( x ) {\n return function add( y ) {\n return x + y;\n };\n};\nfcn = uncurry( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addX( x ) {\n this.x = x;\n return addY;\n};\nfunction addY( y ) {\n return this.x + y;\n};\nfcn = uncurry( addX, {} );\nsum = fcn( 2, 3 )\n","uncurryRight":"function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nvar fcn = uncurryRight( addX );\nvar sum = fcn( 3, 2 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( y ) {\n return function add( x ) {\n return x + y;\n };\n};\nfcn = uncurryRight( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addY( y ) {\n this.y = y;\n return addX;\n};\nfunction addX( x ) {\n return x + this.y;\n};\nfcn = uncurryRight( addY, {} );\nsum = fcn( 3, 2 )\n","UNICODE_MAX":"UNICODE_MAX\n","UNICODE_MAX_BMP":"UNICODE_MAX_BMP\n","UnicodeColumnChartSparkline":"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeColumnChartSparkline( data );\nchart.render()\n","UnicodeLineChartSparkline":"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeLineChartSparkline( data );\nchart.render()\n","UnicodeSparkline":"var data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nvar chart = new UnicodeSparkline( data );\nchart.render()\nchart.type = 'line';\nchart.render()\n","UnicodeTristateChartSparkline":"var data = [ -1, 1, 0, 0, 1, -1, -1, 1 ];\nvar chart = new UnicodeTristateChartSparkline( data );\nchart.render()\n","UnicodeUpDownChartSparkline":"var data = [ -1, 1, 1, 1, 1, -1, -1, 1 ];\nvar chart = new UnicodeUpDownChartSparkline( data );\nchart.render()\n","UnicodeWinLossChartSparkline":"var data = [ -2, 1, 2, 2, 1, -1, -1, 1 ];\nvar chart = new UnicodeWinLossChartSparkline( data );\nchart.render()\n","unlink":"function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nunlink( './beep/boop.txt', done );\n","unshift":"\n// Arrays:\nvar arr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = unshift( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = unshift( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = unshift( arr, 2.0, 3.0 )\n","until":"function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nuntil( predicate, beep )\n","untilAsync":"function predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nuntilAsync( predicate, fcn, done )\n","untilEach":"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\nuntilEach( arr, predicate, logger )\n","untilEachRight":"function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\nuntilEachRight( arr, predicate, logger )\n","unzip":"\n// Basic usage:\nvar arr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nvar out = unzip( arr )\n\n// Provide indices:\narr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nout = unzip( arr, [ 0, 2 ] )\n","uppercase":"var out = uppercase( 'bEEp' )\n","uppercaseKeys":"var obj = { 'a': 1, 'b': 2 };\nvar out = uppercaseKeys( obj )\n","US_STATES_ABBR":"var list = US_STATES_ABBR()\n","US_STATES_CAPITALS":"var list = US_STATES_CAPITALS()\n","US_STATES_CAPITALS_NAMES":"var out = US_STATES_CAPITALS_NAMES()\n","US_STATES_NAMES":"var list = US_STATES_NAMES()\n","US_STATES_NAMES_CAPITALS":"var out = US_STATES_NAMES_CAPITALS()\n","utf16ToUTF8Array":"var str = '☃';\nvar out = utf16ToUTF8Array( str )\n","vartest":"var x = [ 610, 610, 550, 590, 565, 570 ];\nvar y = [ 560, 550, 580, 550, 560, 590, 550, 590 ];\nvar out = vartest( x, y )\n\n// Print table output:\nvar table = out.print()\n","waterfall":"function foo( next ) { next( null, 'beep' ); };\nfunction bar( str, next ) { console.log( str ); next(); };\nfunction done( error ) { if ( error ) { throw error; } };\nvar fcns = [ foo, bar ];\nwaterfall( fcns, done );\n","whileAsync":"function predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nwhileAsync( predicate, fcn, done )\n","whileEach":"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, 2, 3, 4, NaN, 5 ];\nwhileEach( arr, predicate, logger )\n","whileEachRight":"function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\nvar arr = [ 1, NaN, 2, 3, 4, 5 ];\nwhileEachRight( arr, predicate, logger )\n","whilst":"function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nwhilst( predicate, beep )\n","writableProperties":"function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nvar obj = new Foo();\nvar props = writableProperties( obj )\n","writablePropertiesIn":"var props = writablePropertiesIn( [] )\n","writablePropertyNames":"var obj = { 'a': 'b' };\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = writablePropertyNames( obj )\n","writablePropertyNamesIn":"var obj = { 'a': 'b' };\nvar desc = {};\ndesc.configurable = true;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nvar keys = writablePropertyNamesIn( obj )\n","writablePropertySymbols":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = writablePropertySymbols( obj )\n","writablePropertySymbolsIn":"var obj = {};\nvar desc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nvar sym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nvar symbols = writablePropertySymbolsIn( obj )\n","writeFile":"function onWrite( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nwriteFile( './beep/boop.txt', 'beep boop', onWrite );\n","zip":"\n// Basic usage:\nvar out = zip( [ 1, 2 ], [ 'a', 'b' ] )\n\n// Turn off truncation:\nvar opts = { 'trunc': false };\nout = zip( [ 1, 2, 3 ], [ 'a', 'b' ], opts )\n","ztest":"\n// One-sample z-test:\nvar rnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 212 });\nvar x = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nvar out = ztest( x, 2.0 )\n\n// Choose custom significance level and print output:\narr = [ 2, 4, 3, 1, 0 ];\nout = ztest( arr, 2.0, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\nvar arr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'alternative': 'less' })\nout = ztest( arr, 1.0, { 'alternative': 'greater' })\n","ztest2":"\n// Drawn from Normal(0,2):\nvar x = [ -0.21, 0.14, 1.65, 2.11, -1.86, -0.29, 1.48, 0.81, 0.86, 1.04 ];\n\n// Drawn from Normal(1,2):\nvar y = [ -1.53, -2.93, 2.34, -1.15, 2.7, -0.12, 4.22, 1.66, 3.43, 4.66 ];\nvar out = ztest2( x, y, 2.0, 2.0 )\n\n// Print table output:\nvar table = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ztest2( x, y, 2.0, 2.0, { 'alpha': 0.4 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'less' });\ntable = out.print()\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'greater' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nvar rnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 1.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 0.0, 2.0 );\n}\nout = ztest2( x, y, 1.0, 2.0, { 'difference': 2.0 })\n"}
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/datapackage.json b/lib/node_modules/@stdlib/repl/code-blocks/datapackage.json
new file mode 100644
index 000000000000..0faf1f06d843
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/datapackage.json
@@ -0,0 +1,61 @@
+{
+ "name": "stdlib-alias-example",
+ "version": "",
+ "title": "Standard Library Aliases and Examples",
+ "description": "A mapping between standard library aliases and examples.",
+ "resources": [
+ {
+ "name": "stdlib-alias-example-json",
+ "title": "Standard Library Aliases and Examples",
+ "description": "A mapping between standard library aliases and examples.",
+ "format": "json",
+ "mediatype": "application/json",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.json"
+ },
+ {
+ "name": "stdlib-alias-example-csv",
+ "title": "Standard Library Aliases and Examples",
+ "description": "A mapping between standard library aliases and examples.",
+ "format": "csv",
+ "mediatype": "plain/csv",
+ "encoding": "UTF-8",
+ "hash": "",
+ "path": "./data/data.csv",
+ "schema": {
+ "fields": [
+ {
+ "name": "alias",
+ "title": "Alias",
+ "description": "Alias.",
+ "type": "string",
+ "format": "default"
+ },
+ {
+ "name": "example",
+ "title": "Example",
+ "description": "Example.",
+ "type": "string",
+ "format": "default"
+ }
+ ]
+ }
+ }
+ ],
+ "sources": [],
+ "keywords": [
+ "stdlib",
+ "namespace",
+ "aliases",
+ "example",
+ "eg",
+ "help",
+ "docs",
+ "documentation",
+ "repl",
+ "usage",
+ "demo"
+ ],
+ "license": "PDDL-1.0 AND CC0-1.0"
+}
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/docs/repl.txt b/lib/node_modules/@stdlib/repl/code-blocks/docs/repl.txt
new file mode 100644
index 000000000000..a0e2aa008b02
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/docs/repl.txt
@@ -0,0 +1,21 @@
+
+{{alias}}( alias )
+ Returns an example associated with a provided alias.
+
+ Parameters
+ ----------
+ alias: string
+ Alias.
+
+ Returns
+ -------
+ out: string|null
+ Example.
+
+ Examples
+ --------
+ > var txt = {{alias}}( '{{alias:@stdlib/math/base/special/sin}}' )
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/docs/types/index.d.ts b/lib/node_modules/@stdlib/repl/code-blocks/docs/types/index.d.ts
new file mode 100644
index 000000000000..7eac677a794c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/docs/types/index.d.ts
@@ -0,0 +1,35 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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: 2.0
+
+/**
+* Returns an example associated with a specified alias.
+*
+* @param alias - alias
+* @returns example
+*
+* @example
+* var out = example( 'base.sin' );
+*/
+declare function example( alias: string ): string | null;
+
+
+// EXPORTS //
+
+export = example;
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/docs/types/test.ts b/lib/node_modules/@stdlib/repl/code-blocks/docs/types/test.ts
new file mode 100644
index 000000000000..e153d4adbb48
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/docs/types/test.ts
@@ -0,0 +1,44 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 example = require( './index' );
+
+
+// TESTS //
+
+// The function returns a string or null...
+{
+ example( 'base.sin' ); // $ExpectType string | null
+}
+
+// The compiler throws an error if the function is not provided a string...
+{
+ example( 5 ); // $ExpectError
+ example( true ); // $ExpectError
+ example( false ); // $ExpectError
+ example( null ); // $ExpectError
+ example( undefined ); // $ExpectError
+ example( [] ); // $ExpectError
+ example( {} ); // $ExpectError
+ example( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ example( 'base.sin', 'beep' ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/docs/usage.txt b/lib/node_modules/@stdlib/repl/code-blocks/docs/usage.txt
new file mode 100644
index 000000000000..064d0cdace3d
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/docs/usage.txt
@@ -0,0 +1,8 @@
+
+Usage: stdlib-alias-example [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/etc/cli_opts.json b/lib/node_modules/@stdlib/repl/code-blocks/etc/cli_opts.json
new file mode 100644
index 000000000000..92119c456962
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/etc/cli_opts.json
@@ -0,0 +1,15 @@
+{
+ "string": [],
+ "boolean": [
+ "help",
+ "version"
+ ],
+ "alias": {
+ "help": [
+ "h"
+ ],
+ "version": [
+ "V"
+ ]
+ }
+}
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/examples/index.js b/lib/node_modules/@stdlib/repl/code-blocks/examples/index.js
index e2bee8766744..ce6a0e2fa935 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/examples/index.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/examples/index.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -18,8 +18,19 @@
'use strict';
-var examples = require( './../lib' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var example = require( './../lib' );
-var db = examples();
-console.log( db );
-// => {...}
+var list;
+var len;
+var idx;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ console.log( example( list[ idx ] ) );
+}
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/lib/db.js b/lib/node_modules/@stdlib/repl/code-blocks/lib/db.js
deleted file mode 100644
index 13450b5aee80..000000000000
--- a/lib/node_modules/@stdlib/repl/code-blocks/lib/db.js
+++ /dev/null
@@ -1,1903 +0,0 @@
-/* eslint-disable quotes, max-lines */
-
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2019 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.
-*/
-
-/*
-* This file is generated by scripts/build.js.
-*/
-'use strict';
-
-var db = {
- "AFINN_96": "list = AFINN_96()\n",
- "AFINN_111": "list = AFINN_111()\n",
- "allocUnsafe": "buf = allocUnsafe( 100 )\n",
- "anova1": "x = [1, 3, 5, 2, 4, 6, 8, 7, 10, 11, 12, 15];\nf = [\n'control', 'treatA', 'treatB', 'treatC', 'control',\n'treatA', 'treatB', 'treatC', 'control', 'treatA', 'treatB', 'treatC'\n];\nout = anova1( x, f )\n",
- "ANSCOMBES_QUARTET": "d = ANSCOMBES_QUARTET()\n",
- "any": "arr = [ 0, 0, 0, 0, 1 ];\nbool = any( arr )\n",
- "anyBy": "function negative( v ) { return ( v < 0 ); };\narr = [ 1, 2, 3, 4, -1 ];\nbool = anyBy( arr, negative )\n",
- "anyByAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\nanyByAsync( arr, opts, predicate, done )\n",
- "anyByRight": "function negative( v ) { return ( v < 0 ); };\narr = [ -1, 1, 2, 3, 4 ];\nbool = anyByRight( arr, negative )\n",
- "anyByRightAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\nanyByRightAsync( arr, opts, predicate, done )\n",
- "APERY": "APERY\n",
- "append": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = append( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = append( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 0 };\narr = append( arr, [ 1.0, 2.0 ] )\n",
- "ARCH": "ARCH\n",
- "argumentFunction": "argn = argumentFunction( 1 );\nv = argn( 3.14, -3.14, 0.0 )\nv = argn( -1.0, -0.0, 1.0 )\nv = argn( 'beep', 'boop', 'bop' )\nv = argn( 'beep' )\n",
- "ARGV": "execPath = ARGV[ 0 ]\n",
- "array": "\n// Create a 2x2 matrix:\narr = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] )\n\n// Get an element using subscripts:\nv = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n",
- "array2buffer": "buf = array2buffer( [ 1, 2, 3, 4 ] )\n",
- "array2iterator": "it = array2iterator( [ 1, 2, 3, 4 ] );\nv = it.next().value\nv = it.next().value\n",
- "array2iteratorRight": "it = array2iteratorRight( [ 1, 2, 3, 4 ] );\nv = it.next().value\nv = it.next().value\n",
- "ArrayBuffer": "buf = new ArrayBuffer( 5 )\n",
- "arraybuffer2buffer": "ab = new ArrayBuffer( 10 )\nbuf = arraybuffer2buffer( ab )\nlen = buf.length\nbuf = arraybuffer2buffer( ab, 2, 6 )\nlen = buf.length\n",
- "arrayCtors": "ctor = arrayCtors( 'float64' )\nctor = arrayCtors( 'float' )\n",
- "arrayDataType": "arr = new Float64Array( 10 );\ndt = arrayDataType( arr )\ndt = arrayDataType( 'beep' )\n",
- "arrayDataTypes": "out = arrayDataTypes()\n",
- "arrayMinDataType": "dt = arrayMinDataType( 3.141592653589793 )\ndt = arrayMinDataType( 3 )\ndt = arrayMinDataType( -3 )\ndt = arrayMinDataType( '-3' )\n",
- "arrayNextDataType": "out = arrayNextDataType( 'float32' )\n",
- "arrayPromotionRules": "out = arrayPromotionRules( 'float32', 'int32' )\n",
- "arraySafeCasts": "out = arraySafeCasts( 'float32' )\n",
- "arraySameKindCasts": "out = arraySameKindCasts( 'float32' )\n",
- "arrayShape": "out = arrayShape( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] )\n",
- "arrayStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\ns = arrayStream( [ 1, 2, 3 ] );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "arrayview2iterator": "it = arrayview2iterator( [ 1, 2, 3, 4 ], 1, 3 );\nv = it.next().value\nv = it.next().value\n",
- "arrayview2iteratorRight": "it = arrayview2iteratorRight( [ 1, 2, 3, 4 ], 1, 3 );\nv = it.next().value\nv = it.next().value\n",
- "AsyncIteratorSymbol": "s = AsyncIteratorSymbol\n",
- "bartlettTest": "\n// Data from Hollander & Wolfe (1973), p. 116:\nx = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\ny = [ 3.8, 2.7, 4.0, 2.4 ];\nz = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nout = bartlettTest( x, y, z )\narr = [ 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];\ngroups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = bartlettTest( arr, { 'groups': groups })\n",
- "base.abs": "y = base.abs( -1.0 )\ny = base.abs( 2.0 )\ny = base.abs( 0.0 )\ny = base.abs( -0.0 )\ny = base.abs( NaN )\n",
- "base.abs2": "y = base.abs2( -1.0 )\ny = base.abs2( 2.0 )\ny = base.abs2( 0.0 )\ny = base.abs2( -0.0 )\ny = base.abs2( NaN )\n",
- "base.absdiff": "d = base.absdiff( 2.0, 5.0 )\nd = base.absdiff( -1.0, 3.14 )\nd = base.absdiff( 10.1, -2.05 )\nd = base.absdiff( -0.0, 0.0 )\nd = base.absdiff( NaN, 5.0 )\nd = base.absdiff( PINF, NINF )\nd = base.absdiff( PINF, PINF )\n",
- "base.absInt32": "v = base.absInt32( -1|0 )\nv = base.absInt32( 2|0 )\nv = base.absInt32( 0|0 )\n",
- "base.acos": "y = base.acos( 1.0 )\ny = base.acos( 0.707 )\ny = base.acos( NaN )\n",
- "base.acosh": "y = base.acosh( 1.0 )\ny = base.acosh( 2.0 )\ny = base.acosh( NaN )\n",
- "base.acoth": "y = base.acoth( 2.0 )\ny = base.acoth( 0.0 )\ny = base.acoth( 0.5 )\ny = base.acoth( 1.0 )\ny = base.acoth( NaN )\n",
- "base.acovercos": "y = base.acovercos( -1.5 )\ny = base.acovercos( -0.0 )\n",
- "base.acoversin": "y = base.acoversin( 1.5 )\ny = base.acoversin( 0.0 )\n",
- "base.ahavercos": "y = base.ahavercos( 0.5 )\ny = base.ahavercos( 0.0 )\n",
- "base.ahaversin": "y = base.ahaversin( 0.5 )\ny = base.ahaversin( 0.0 )\n",
- "base.asin": "y = base.asin( 0.0 )\ny = base.asin( PI/2.0 )\ny = base.asin( -PI/6.0 )\ny = base.asin( NaN )\n",
- "base.asinh": "y = base.asinh( 0.0 )\ny = base.asinh( 2.0 )\ny = base.asinh( -2.0 )\ny = base.asinh( NaN )\ny = base.asinh( NINF )\ny = base.asinh( PINF )\n",
- "base.atan": "y = base.atan( 0.0 )\ny = base.atan( -PI/2.0 )\ny = base.atan( PI/2.0 )\ny = base.atan( NaN )\n",
- "base.atan2": "v = base.atan2( 2.0, 2.0 )\nv = base.atan2( 6.0, 2.0 )\nv = base.atan2( -1.0, -1.0 )\nv = base.atan2( 3.0, 0.0 )\nv = base.atan2( -2.0, 0.0 )\nv = base.atan2( 0.0, 0.0 )\nv = base.atan2( 3.0, NaN )\nv = base.atan2( NaN, 2.0 )\n",
- "base.atanh": "y = base.atanh( 0.0 )\ny = base.atanh( 0.9 )\ny = base.atanh( 1.0 )\ny = base.atanh( -1.0 )\ny = base.atanh( NaN )\n",
- "base.avercos": "y = base.avercos( -1.5 )\ny = base.avercos( -0.0 )\n",
- "base.aversin": "y = base.aversin( 1.5 )\ny = base.aversin( 0.0 )\n",
- "base.bernoulli": "y = base.bernoulli( 0 )\ny = base.bernoulli( 1 )\ny = base.bernoulli( 2 )\ny = base.bernoulli( 3 )\ny = base.bernoulli( 4 )\ny = base.bernoulli( 5 )\ny = base.bernoulli( 20 )\ny = base.bernoulli( 260 )\ny = base.bernoulli( 262 )\ny = base.bernoulli( NaN )\n",
- "base.besselj0": "y = base.besselj0( 0.0 )\ny = base.besselj0( 1.0 )\ny = base.besselj0( PINF )\ny = base.besselj0( NINF )\ny = base.besselj0( NaN )\n",
- "base.besselj1": "y = base.besselj1( 0.0 )\ny = base.besselj1( 1.0 )\ny = base.besselj1( PINF )\ny = base.besselj1( NINF )\ny = base.besselj1( NaN )\n",
- "base.bessely0": "y = base.bessely0( 0.0 )\ny = base.bessely0( 1.0 )\ny = base.bessely0( -1.0 )\ny = base.bessely0( PINF )\ny = base.bessely0( NINF )\ny = base.bessely0( NaN )\n",
- "base.bessely1": "y = base.bessely1( 0.0 )\ny = base.bessely1( 1.0 )\ny = base.bessely1( -1.0 )\ny = base.bessely1( PINF )\ny = base.bessely1( NINF )\ny = base.bessely1( NaN )\n",
- "base.beta": "v = base.beta( 0.0, 0.5 )\nv = base.beta( 1.0, 1.0 )\nv = base.beta( -1.0, 2.0 )\nv = base.beta( 5.0, 0.2 )\nv = base.beta( 4.0, 1.0 )\nv = base.beta( NaN, 2.0 )\n",
- "base.betainc": "y = base.betainc( 0.5, 2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, 2.0, false )\ny = base.betainc( 0.2, 1.0, 2.0 )\ny = base.betainc( 0.2, 1.0, 2.0, true, true )\ny = base.betainc( NaN, 1.0, 1.0 )\ny = base.betainc( 0.8, NaN, 1.0 )\ny = base.betainc( 0.8, 1.0, NaN )\ny = base.betainc( 1.5, 1.0, 1.0 )\ny = base.betainc( -0.5, 1.0, 1.0 )\ny = base.betainc( 0.5, -2.0, 2.0 )\ny = base.betainc( 0.5, 2.0, -2.0 )\n",
- "base.betaincinv": "y = base.betaincinv( 0.2, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0 )\ny = base.betaincinv( 0.4, 3.0, 3.0, true )\ny = base.betaincinv( 0.4, 1.0, 6.0 )\ny = base.betaincinv( 0.8, 1.0, 6.0 )\ny = base.betaincinv( NaN, 1.0, 1.0 )\ny = base.betaincinv( 0.5, NaN, 1.0 )\ny = base.betaincinv( 0.5, 1.0, NaN )\ny = base.betaincinv( 1.2, 1.0, 1.0 )\ny = base.betaincinv( -0.5, 1.0, 1.0 )\ny = base.betaincinv( 0.5, -2.0, 2.0 )\ny = base.betaincinv( 0.5, 0.0, 2.0 )\ny = base.betaincinv( 0.5, 2.0, -2.0 )\ny = base.betaincinv( 0.5, 2.0, 0.0 )\n",
- "base.betaln": "v = base.betaln( 0.0, 0.0 )\nv = base.betaln( 1.0, 1.0 )\nv = base.betaln( -1.0, 2.0 )\nv = base.betaln( 5.0, 0.2 )\nv = base.betaln( 4.0, 1.0 )\nv = base.betaln( NaN, 2.0 )\n",
- "base.binet": "y = base.binet( 0.0 )\ny = base.binet( 1.0 )\ny = base.binet( 2.0 )\ny = base.binet( 3.0 )\ny = base.binet( 4.0 )\ny = base.binet( 5.0 )\ny = base.binet( NaN )\n",
- "base.binomcoef": "v = base.binomcoef( 8, 2 )\nv = base.binomcoef( 0, 0 )\nv = base.binomcoef( -4, 2 )\nv = base.binomcoef( 5, 3 )\nv = base.binomcoef( NaN, 3 )\nv = base.binomcoef( 5, NaN )\nv = base.binomcoef( NaN, NaN )\n",
- "base.binomcoefln": "v = base.binomcoefln( 8, 2 )\nv = base.binomcoefln( 0, 0 )\nv = base.binomcoefln( -4, 2 )\nv = base.binomcoefln( 88, 3 )\nv = base.binomcoefln( NaN, 3 )\nv = base.binomcoefln( 5, NaN )\nv = base.binomcoefln( NaN, NaN )\n",
- "base.boxcox": "v = base.boxcox( 1.0, 2.5 )\nv = base.boxcox( 4.0, 2.5 )\nv = base.boxcox( 10.0, 2.5 )\nv = base.boxcox( 2.0, 0.0 )\nv = base.boxcox( -1.0, 2.5 )\nv = base.boxcox( 0.0, -1.0 )\n",
- "base.boxcox1p": "v = base.boxcox1p( 1.0, 2.5 )\nv = base.boxcox1p( 4.0, 2.5 )\nv = base.boxcox1p( 10.0, 2.5 )\nv = base.boxcox1p( 2.0, 0.0 )\nv = base.boxcox1p( -1.0, 2.5 )\nv = base.boxcox1p( 0.0, -1.0 )\nv = base.boxcox1p( -1.0, -1.0 )\n",
- "base.boxcox1pinv": "v = base.boxcox1pinv( 1.0, 2.5 )\nv = base.boxcox1pinv( 4.0, 2.5 )\nv = base.boxcox1pinv( 10.0, 2.5 )\nv = base.boxcox1pinv( 2.0, 0.0 )\nv = base.boxcox1pinv( -1.0, 2.5 )\nv = base.boxcox1pinv( 0.0, -1.0 )\nv = base.boxcox1pinv( 1.0, NaN )\nv = base.boxcox1pinv( NaN, 3.1 )\n",
- "base.boxcoxinv": "v = base.boxcoxinv( 1.0, 2.5 )\nv = base.boxcoxinv( 4.0, 2.5 )\nv = base.boxcoxinv( 10.0, 2.5 )\nv = base.boxcoxinv( 2.0, 0.0 )\nv = base.boxcoxinv( -1.0, 2.5 )\nv = base.boxcoxinv( 0.0, -1.0 )\nv = base.boxcoxinv( 1.0, NaN )\nv = base.boxcoxinv( NaN, 3.1 )\n",
- "base.cabs": "y = base.cabs( 5.0, 3.0 )\n",
- "base.cabs2": "y = base.cabs2( 5.0, 3.0 )\n",
- "base.cadd": "y = base.cadd( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nout = new Float32Array( 2 );\ny = base.cadd( out, 5.0, 3.0, -2.0, 1.0 )\nbool = ( y === out )\n",
- "base.cbrt": "y = base.cbrt( 64.0 )\ny = base.cbrt( 27.0 )\ny = base.cbrt( 0.0 )\ny = base.cbrt( -0.0 )\ny = base.cbrt( -9.0 )\ny = base.cbrt( NaN )\n",
- "base.cceil": "out = base.cceil( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cceil( out, 5.5, 3.3 )\nbool = ( v === out )\n",
- "base.cceiln": "out = base.cceiln( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cceiln( out, 5.555, -3.333, -2 )\nbool = ( v === out )\n",
- "base.ccis": "y = base.ccis( 0.0, 0.0 )\ny = base.ccis( 1.0, 0.0 )\nout = new Float64Array( 2 );\nv = base.ccis( out, 1.0, 0.0 )\nbool = ( v === out )\n",
- "base.cdiv": "y = base.cdiv( -13.0, -1.0, -2.0, 1.0 )\nout = new Float64Array( 2 );\nv = base.cdiv( out, -13.0, -1.0, -2.0, 1.0 )\nbool = ( v === out )\n",
- "base.ceil": "y = base.ceil( 3.14 )\ny = base.ceil( -4.2 )\ny = base.ceil( -4.6 )\ny = base.ceil( 9.5 )\ny = base.ceil( -0.0 )\n",
- "base.ceil2": "y = base.ceil2( 3.14 )\ny = base.ceil2( -4.2 )\ny = base.ceil2( -4.6 )\ny = base.ceil2( 9.5 )\ny = base.ceil2( 13.0 )\ny = base.ceil2( -13.0 )\ny = base.ceil2( -0.0 )\n",
- "base.ceil10": "y = base.ceil10( 3.14 )\ny = base.ceil10( -4.2 )\ny = base.ceil10( -4.6 )\ny = base.ceil10( 9.5 )\ny = base.ceil10( 13.0 )\ny = base.ceil10( -13.0 )\ny = base.ceil10( -0.0 )\n",
- "base.ceilb": "\n// Round to 4 decimal places:\ny = base.ceilb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.ceilb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward positive infinity:\ny = base.ceilb( 5.0, 1, 2 )\n",
- "base.ceiln": "\n// Round to 2 decimal places:\ny = base.ceiln( 3.14159, -2 )\n\n// If `n = 0`, standard round toward positive infinity behavior:\ny = base.ceiln( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.ceiln( 12368.0, 3 )\n",
- "base.ceilsd": "y = base.ceilsd( 3.14159, 5 )\ny = base.ceilsd( 3.14159, 1 )\ny = base.ceilsd( 12368.0, 2 )\ny = base.ceilsd( 0.0313, 2, 2 )\n",
- "base.cexp": "y = base.cexp( 0.0, 0.0 )\ny = base.cexp( 0.0, 1.0 )\nout = new Float64Array( 2 );\nv = base.cexp( out, 0.0, 1.0 )\nbool = ( v === out )\n",
- "base.cflipsign": "out = base.cflipsign( -4.2, 5.5, -9 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cflipsign( out, -4.2, 5.5, 8 )\nbool = ( v === out )\n",
- "base.cfloor": "out = base.cfloor( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cfloor( out, 5.5, 3.3 )\nbool = ( v === out )\n",
- "base.cfloorn": "out = base.cfloorn( 5.555, -3.333, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cfloorn( out, 5.555, -3.333, -2 )\nbool = ( v === out )\n",
- "base.cinv": "y = base.cinv( 2.0, 4.0 )\nout = new Float64Array( 2 );\nv = base.cinv( out, 2.0, 4.0 )\nbool = ( v === out )\n",
- "base.clamp": "y = base.clamp( 3.14, 0.0, 5.0 )\ny = base.clamp( -3.14, 0.0, 5.0 )\ny = base.clamp( 3.14, 0.0, 3.0 )\ny = base.clamp( -0.0, 0.0, 5.0 )\ny = base.clamp( 0.0, -3.14, -0.0 )\ny = base.clamp( NaN, 0.0, 5.0 )\n",
- "base.cmul": "out = base.cmul( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cmul( out, 5.0, 3.0, -2.0, 1.0 )\nbool = ( v === out )\n",
- "base.cneg": "out = base.cneg( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cneg( out, -4.2, 5.5 )\nbool = ( v === out )\n",
- "base.continuedFraction": "\n// Continued fraction for (e-1)^(-1):\nfunction closure() {\n var i = 0;\n return function() {\n i += 1;\n return [ i, i ];\n };\n};\ngen = closure();\nout = base.continuedFraction( gen )\n\n// Using an ES6 generator:\nfunction* generator() {\n var i = 0;\n while ( true ) {\n i += 1;\n yield [ i, i ];\n }\n};\ngen = generator();\nout = base.continuedFraction( gen )\n\n// Set options:\nout = base.continuedFraction( generator(), { 'keep': true } )\nout = base.continuedFraction( generator(), { 'maxIter': 10 } )\nout = base.continuedFraction( generator(), { 'tolerance': 1e-1 } )\n",
- "base.copysign": "z = base.copysign( -3.14, 10.0 )\nz = base.copysign( 3.14, -1.0 )\nz = base.copysign( 1.0, -0.0 )\nz = base.copysign( -3.14, -0.0 )\nz = base.copysign( -0.0, 1.0 )\n",
- "base.cos": "y = base.cos( 0.0 )\ny = base.cos( PI/4.0 )\ny = base.cos( -PI/6.0 )\ny = base.cos( NaN )\n",
- "base.cosh": "y = base.cosh( 0.0 )\ny = base.cosh( 2.0 )\ny = base.cosh( -2.0 )\ny = base.cosh( NaN )\n",
- "base.cosm1": "y = base.cosm1( 0.0 )\ny = base.cosm1( PI/4.0 )\ny = base.cosm1( -PI/6.0 )\ny = base.cosm1( NaN )\n",
- "base.cospi": "y = base.cospi( 0.0 )\ny = base.cospi( 0.5 )\ny = base.cospi( 0.1 )\ny = base.cospi( NaN )\n",
- "base.covercos": "y = base.covercos( 3.14 )\ny = base.covercos( -4.2 )\ny = base.covercos( -4.6 )\ny = base.covercos( 9.5 )\ny = base.covercos( -0.0 )\n",
- "base.coversin": "y = base.coversin( 3.14 )\ny = base.coversin( -4.2 )\ny = base.coversin( -4.6 )\ny = base.coversin( 9.5 )\ny = base.coversin( -0.0 )\n",
- "base.cphase": "phi = base.cphase( 5.0, 3.0 )\n",
- "base.cpolar": "out = base.cpolar( 5.0, 3.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cpolar( out, 5.0, 3.0 )\nbool = ( v === out )\n",
- "base.cround": "out = base.cround( 5.5, 3.3 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.cround( out, 5.5, 3.3 )\nbool = ( v === out )\n",
- "base.croundn": "out = base.croundn( 5.555, -3.336, -2 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.croundn( out, 5.555, -3.336, -2 )\nbool = ( v === out )\n",
- "base.csignum": "out = base.csignum( -4.2, 5.5 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.csignum( out, -4.2, 5.5 )\nbool = ( v === out )\n",
- "base.csub": "out = base.csub( 5.0, 3.0, -2.0, 1.0 )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.csub( out, 5.0, 3.0, -2.0, 1.0 )\nbool = ( v === out )\n",
- "base.dasum": "\n// Standard usage:\nx = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nsum = base.dasum( x.length, x, 1 )\n\n// Sum every other value:\nN = base.floor( x.length / 2 );\nstride = 2;\nsum = base.dasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nx0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.dasum( N, x1, stride )\n",
- "base.daxpy": "\n// Standard usage:\nx = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\ny = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nalpha = 5.0;\nbase.daxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nN = base.floor( x.length / 2 );\ny = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nbase.daxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nx0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.daxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n",
- "base.dcopy": "\n// Standard usage:\nx = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\ny = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.dcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nN = base.floor( x.length / 2 );\nbase.dcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nx0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.dcopy( N, x1, -2, y1, 1 )\ny0\n",
- "base.deg2rad": "r = base.deg2rad( 90.0 )\nr = base.deg2rad( -45.0 )\nr = base.deg2rad( NaN )\n",
- "base.digamma": "y = base.digamma( -2.5 )\ny = base.digamma( 1.0 )\ny = base.digamma( 10.0 )\ny = base.digamma( NaN )\ny = base.digamma( -1.0 )\n",
- "base.diracDelta": "y = base.diracDelta( 3.14 )\ny = base.diracDelta( 0.0 )\n",
- "base.dists.arcsine.Arcsine": "arcsine = base.dists.arcsine.Arcsine( 0.0, 1.0 );\narcsine.a\narcsine.b\narcsine.entropy\narcsine.kurtosis\narcsine.mean\narcsine.median\narcsine.mode\narcsine.skewness\narcsine.stdev\narcsine.variance\narcsine.cdf( 0.8 )\narcsine.logcdf( 0.8 )\narcsine.logpdf( 0.4 )\narcsine.pdf( 0.8 )\narcsine.quantile( 0.8 )\n",
- "base.dists.arcsine.cdf": "y = base.dists.arcsine.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.cdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.cdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.cdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.cdf( 2.0, 1.0, 0.0 )\n",
- "base.dists.arcsine.entropy": "v = base.dists.arcsine.entropy( 0.0, 1.0 )\nv = base.dists.arcsine.entropy( 4.0, 12.0 )\nv = base.dists.arcsine.entropy( 2.0, 8.0 )\n",
- "base.dists.arcsine.kurtosis": "v = base.dists.arcsine.kurtosis( 0.0, 1.0 )\nv = base.dists.arcsine.kurtosis( 4.0, 12.0 )\nv = base.dists.arcsine.kurtosis( 2.0, 8.0 )\n",
- "base.dists.arcsine.logcdf": "y = base.dists.arcsine.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.arcsine.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.arcsine.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.arcsine.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logcdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logcdf( 2.0, 1.0, 0.0 )\n",
- "base.dists.arcsine.logpdf": "y = base.dists.arcsine.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.logpdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.logpdf( 2.0, 3.0, 1.0 )\n",
- "base.dists.arcsine.mean": "v = base.dists.arcsine.mean( 0.0, 1.0 )\nv = base.dists.arcsine.mean( 4.0, 12.0 )\nv = base.dists.arcsine.mean( 2.0, 8.0 )\n",
- "base.dists.arcsine.median": "v = base.dists.arcsine.median( 0.0, 1.0 )\nv = base.dists.arcsine.median( 4.0, 12.0 )\nv = base.dists.arcsine.median( 2.0, 8.0 )\n",
- "base.dists.arcsine.mode": "v = base.dists.arcsine.mode( 0.0, 1.0 )\nv = base.dists.arcsine.mode( 4.0, 12.0 )\nv = base.dists.arcsine.mode( 2.0, 8.0 )\n",
- "base.dists.arcsine.pdf": "y = base.dists.arcsine.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.arcsine.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.pdf( 0.0, 0.0, NaN )\ny = base.dists.arcsine.pdf( 2.0, 3.0, 1.0 )\n",
- "base.dists.arcsine.quantile": "y = base.dists.arcsine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.arcsine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.arcsine.quantile( 0.0, 0.0, NaN )\ny = base.dists.arcsine.quantile( 0.5, 2.0, 1.0 )\n",
- "base.dists.arcsine.skewness": "v = base.dists.arcsine.skewness( 0.0, 1.0 )\nv = base.dists.arcsine.skewness( 4.0, 12.0 )\nv = base.dists.arcsine.skewness( 2.0, 8.0 )\n",
- "base.dists.arcsine.stdev": "v = base.dists.arcsine.stdev( 0.0, 1.0 )\nv = base.dists.arcsine.stdev( 4.0, 12.0 )\nv = base.dists.arcsine.stdev( 2.0, 8.0 )\n",
- "base.dists.arcsine.variance": "v = base.dists.arcsine.variance( 0.0, 1.0 )\nv = base.dists.arcsine.variance( 4.0, 12.0 )\nv = base.dists.arcsine.variance( 2.0, 8.0 )\n",
- "base.dists.bernoulli.Bernoulli": "bernoulli = base.dists.bernoulli.Bernoulli( 0.6 );\nbernoulli.p\nbernoulli.entropy\nbernoulli.kurtosis\nbernoulli.mean\nbernoulli.median\nbernoulli.skewness\nbernoulli.stdev\nbernoulli.variance\nbernoulli.cdf( 0.5 )\nbernoulli.mgf( 3.0 )\nbernoulli.pmf( 0.0 )\nbernoulli.quantile( 0.7 )\n",
- "base.dists.bernoulli.cdf": "y = base.dists.bernoulli.cdf( 0.5, 0.5 )\ny = base.dists.bernoulli.cdf( 0.8, 0.1 )\ny = base.dists.bernoulli.cdf( -1.0, 0.4 )\ny = base.dists.bernoulli.cdf( 1.5, 0.4 )\ny = base.dists.bernoulli.cdf( NaN, 0.5 )\ny = base.dists.bernoulli.cdf( 0.0, NaN )\n\n// Invalid probability:\ny = base.dists.bernoulli.cdf( 2.0, 1.4 )\n",
- "base.dists.bernoulli.entropy": "v = base.dists.bernoulli.entropy( 0.1 )\nv = base.dists.bernoulli.entropy( 0.5 )\n",
- "base.dists.bernoulli.kurtosis": "v = base.dists.bernoulli.kurtosis( 0.1 )\nv = base.dists.bernoulli.kurtosis( 0.5 )\n",
- "base.dists.bernoulli.mean": "v = base.dists.bernoulli.mean( 0.1 )\nv = base.dists.bernoulli.mean( 0.5 )\n",
- "base.dists.bernoulli.median": "v = base.dists.bernoulli.median( 0.1 )\nv = base.dists.bernoulli.median( 0.8 )\n",
- "base.dists.bernoulli.mgf": "y = base.dists.bernoulli.mgf( 0.2, 0.5 )\ny = base.dists.bernoulli.mgf( 0.4, 0.5 )\ny = base.dists.bernoulli.mgf( NaN, 0.0 )\ny = base.dists.bernoulli.mgf( 0.0, NaN )\ny = base.dists.bernoulli.mgf( -2.0, -1.0 )\ny = base.dists.bernoulli.mgf( 0.2, 2.0 )\n",
- "base.dists.bernoulli.mode": "v = base.dists.bernoulli.mode( 0.1 )\nv = base.dists.bernoulli.mode( 0.8 )\n",
- "base.dists.bernoulli.pmf": "y = base.dists.bernoulli.pmf( 1.0, 0.3 )\ny = base.dists.bernoulli.pmf( 0.0, 0.7 )\ny = base.dists.bernoulli.pmf( -1.0, 0.5 )\ny = base.dists.bernoulli.pmf( 0.0, NaN )\ny = base.dists.bernoulli.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.bernoulli.pmf( 0.0, 1.5 )\n",
- "base.dists.bernoulli.quantile": "y = base.dists.bernoulli.quantile( 0.8, 0.4 )\ny = base.dists.bernoulli.quantile( 0.5, 0.4 )\ny = base.dists.bernoulli.quantile( 0.9, 0.1 )\ny = base.dists.bernoulli.quantile( -0.2, 0.1 )\ny = base.dists.bernoulli.quantile( NaN, 0.8 )\ny = base.dists.bernoulli.quantile( 0.4, NaN )\ny = base.dists.bernoulli.quantile( 0.5, -1.0 )\ny = base.dists.bernoulli.quantile( 0.5, 1.5 )\n",
- "base.dists.bernoulli.skewness": "v = base.dists.bernoulli.skewness( 0.1 )\nv = base.dists.bernoulli.skewness( 0.5 )\n",
- "base.dists.bernoulli.stdev": "v = base.dists.bernoulli.stdev( 0.1 )\nv = base.dists.bernoulli.stdev( 0.5 )\n",
- "base.dists.bernoulli.variance": "v = base.dists.bernoulli.variance( 0.1 )\nv = base.dists.bernoulli.variance( 0.5 )\n",
- "base.dists.beta.Beta": "beta = base.dists.beta.Beta( 1.0, 1.0 );\nbeta.alpha\nbeta.beta\nbeta.entropy\nbeta.kurtosis\nbeta.mean\nbeta.median\nbeta.mode\nbeta.skewness\nbeta.stdev\nbeta.variance\nbeta.cdf( 0.8 )\nbeta.logcdf( 0.8 )\nbeta.logpdf( 1.0 )\nbeta.mgf( 3.14 )\nbeta.pdf( 1.0 )\nbeta.quantile( 0.8 )\n",
- "base.dists.beta.cdf": "y = base.dists.beta.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.cdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.cdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.cdf( 0.0, 1.0, NaN )\n",
- "base.dists.beta.entropy": "v = base.dists.beta.entropy( 1.0, 1.0 )\nv = base.dists.beta.entropy( 4.0, 12.0 )\nv = base.dists.beta.entropy( 8.0, 2.0 )\nv = base.dists.beta.entropy( 1.0, -0.1 )\nv = base.dists.beta.entropy( -0.1, 1.0 )\nv = base.dists.beta.entropy( 2.0, NaN )\nv = base.dists.beta.entropy( NaN, 2.0 )\n",
- "base.dists.beta.kurtosis": "v = base.dists.beta.kurtosis( 1.0, 1.0 )\nv = base.dists.beta.kurtosis( 4.0, 12.0 )\nv = base.dists.beta.kurtosis( 8.0, 2.0 )\nv = base.dists.beta.kurtosis( 1.0, -0.1 )\nv = base.dists.beta.kurtosis( -0.1, 1.0 )\nv = base.dists.beta.kurtosis( 2.0, NaN )\nv = base.dists.beta.kurtosis( NaN, 2.0 )\n",
- "base.dists.beta.logcdf": "y = base.dists.beta.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.beta.logcdf( 0.0, 1.0, NaN )\n",
- "base.dists.beta.logpdf": "y = base.dists.beta.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.logpdf( 0.5, 1.0, NaN )\n",
- "base.dists.beta.mean": "v = base.dists.beta.mean( 1.0, 1.0 )\nv = base.dists.beta.mean( 4.0, 12.0 )\nv = base.dists.beta.mean( 8.0, 2.0 )\n",
- "base.dists.beta.median": "v = base.dists.beta.median( 1.0, 1.0 )\nv = base.dists.beta.median( 4.0, 12.0 )\nv = base.dists.beta.median( 8.0, 2.0 )\nv = base.dists.beta.median( 1.0, -0.1 )\nv = base.dists.beta.median( -0.1, 1.0 )\nv = base.dists.beta.median( 2.0, NaN )\nv = base.dists.beta.median( NaN, 2.0 )\n",
- "base.dists.beta.mgf": "y = base.dists.beta.mgf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.mgf( 3.0, 2.0, 2.0 )\ny = base.dists.beta.mgf( -0.8, 4.0, 4.0 )\ny = base.dists.beta.mgf( NaN, 1.0, 1.0 )\ny = base.dists.beta.mgf( 0.0, NaN, 1.0 )\ny = base.dists.beta.mgf( 0.0, 1.0, NaN )\ny = base.dists.beta.mgf( 2.0, -1.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.0, 0.5 )\ny = base.dists.beta.mgf( 2.0, 0.5, -1.0 )\ny = base.dists.beta.mgf( 2.0, 0.5, 0.0 )\n",
- "base.dists.beta.mode": "v = base.dists.beta.mode( 4.0, 12.0 )\nv = base.dists.beta.mode( 8.0, 2.0 )\nv = base.dists.beta.mode( 1.0, 1.0 )\n",
- "base.dists.beta.pdf": "y = base.dists.beta.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.beta.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.beta.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.beta.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.beta.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.beta.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.beta.pdf( NaN, 1.0, 1.0 )\ny = base.dists.beta.pdf( 0.5, NaN, 1.0 )\ny = base.dists.beta.pdf( 0.5, 1.0, NaN )\n",
- "base.dists.beta.quantile": "y = base.dists.beta.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.beta.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.beta.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.beta.quantile( NaN, 1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, NaN, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, NaN )\ny = base.dists.beta.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.beta.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.beta.skewness": "v = base.dists.beta.skewness( 1.0, 1.0 )\nv = base.dists.beta.skewness( 4.0, 12.0 )\nv = base.dists.beta.skewness( 8.0, 2.0 )\nv = base.dists.beta.skewness( 1.0, -0.1 )\nv = base.dists.beta.skewness( -0.1, 1.0 )\nv = base.dists.beta.skewness( 2.0, NaN )\nv = base.dists.beta.skewness( NaN, 2.0 )\n",
- "base.dists.beta.stdev": "v = base.dists.beta.stdev( 1.0, 1.0 )\nv = base.dists.beta.stdev( 4.0, 12.0 )\nv = base.dists.beta.stdev( 8.0, 2.0 )\nv = base.dists.beta.stdev( 1.0, -0.1 )\nv = base.dists.beta.stdev( -0.1, 1.0 )\nv = base.dists.beta.stdev( 2.0, NaN )\nv = base.dists.beta.stdev( NaN, 2.0 )\n",
- "base.dists.beta.variance": "v = base.dists.beta.variance( 1.0, 1.0 )\nv = base.dists.beta.variance( 4.0, 12.0 )\nv = base.dists.beta.variance( 8.0, 2.0 )\nv = base.dists.beta.variance( 1.0, -0.1 )\nv = base.dists.beta.variance( -0.1, 1.0 )\nv = base.dists.beta.variance( 2.0, NaN )\nv = base.dists.beta.variance( NaN, 2.0 )\n",
- "base.dists.betaprime.BetaPrime": "betaprime = base.dists.betaprime.BetaPrime( 6.0, 5.0 );\nbetaprime.alpha\nbetaprime.beta\nbetaprime.kurtosis\nbetaprime.mean\nbetaprime.mode\nbetaprime.skewness\nbetaprime.stdev\nbetaprime.variance\nbetaprime.cdf( 0.8 )\nbetaprime.logcdf( 0.8 )\nbetaprime.logpdf( 1.0 )\nbetaprime.pdf( 1.0 )\nbetaprime.quantile( 0.8 )\n",
- "base.dists.betaprime.cdf": "y = base.dists.betaprime.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.cdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.cdf( 0.0, 1.0, NaN )\n",
- "base.dists.betaprime.kurtosis": "v = base.dists.betaprime.kurtosis( 2.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 4.0, 12.0 )\nv = base.dists.betaprime.kurtosis( 8.0, 6.0 )\nv = base.dists.betaprime.kurtosis( 1.0, 2.8 )\nv = base.dists.betaprime.kurtosis( 1.0, -0.1 )\nv = base.dists.betaprime.kurtosis( -0.1, 5.0 )\nv = base.dists.betaprime.kurtosis( 2.0, NaN )\nv = base.dists.betaprime.kurtosis( NaN, 6.0 )\n",
- "base.dists.betaprime.logcdf": "y = base.dists.betaprime.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.betaprime.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.betaprime.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.betaprime.logcdf( 0.0, 1.0, NaN )\n",
- "base.dists.betaprime.logpdf": "y = base.dists.betaprime.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.logpdf( 0.5, 1.0, NaN )\n",
- "base.dists.betaprime.mean": "v = base.dists.betaprime.mean( 1.0, 2.0 )\nv = base.dists.betaprime.mean( 4.0, 12.0 )\nv = base.dists.betaprime.mean( 8.0, 2.0 )\n",
- "base.dists.betaprime.mode": "v = base.dists.betaprime.mode( 1.0, 2.0 )\nv = base.dists.betaprime.mode( 4.0, 12.0 )\nv = base.dists.betaprime.mode( 8.0, 2.0 )\n",
- "base.dists.betaprime.pdf": "y = base.dists.betaprime.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.betaprime.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.betaprime.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.betaprime.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.betaprime.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.betaprime.pdf( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.pdf( 0.5, 1.0, NaN )\n",
- "base.dists.betaprime.quantile": "y = base.dists.betaprime.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.betaprime.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( NaN, 1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, NaN, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, NaN )\ny = base.dists.betaprime.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.betaprime.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.betaprime.skewness": "v = base.dists.betaprime.skewness( 2.0, 4.0 )\nv = base.dists.betaprime.skewness( 4.0, 12.0 )\nv = base.dists.betaprime.skewness( 8.0, 4.0 )\nv = base.dists.betaprime.skewness( 1.0, 2.8 )\nv = base.dists.betaprime.skewness( 1.0, -0.1 )\nv = base.dists.betaprime.skewness( -0.1, 4.0 )\nv = base.dists.betaprime.skewness( 2.0, NaN )\nv = base.dists.betaprime.skewness( NaN, 4.0 )\n",
- "base.dists.betaprime.stdev": "v = base.dists.betaprime.stdev( 1.0, 2.5 )\nv = base.dists.betaprime.stdev( 4.0, 12.0 )\nv = base.dists.betaprime.stdev( 8.0, 2.5 )\nv = base.dists.betaprime.stdev( 8.0, 1.0 )\nv = base.dists.betaprime.stdev( 1.0, -0.1 )\nv = base.dists.betaprime.stdev( -0.1, 3.0 )\nv = base.dists.betaprime.stdev( 2.0, NaN )\nv = base.dists.betaprime.stdev( NaN, 3.0 )\n",
- "base.dists.betaprime.variance": "v = base.dists.betaprime.variance( 1.0, 2.5 )\nv = base.dists.betaprime.variance( 4.0, 12.0 )\nv = base.dists.betaprime.variance( 8.0, 2.5 )\nv = base.dists.betaprime.variance( 8.0, 1.0 )\nv = base.dists.betaprime.variance( 1.0, -0.1 )\nv = base.dists.betaprime.variance( -0.1, 3.0 )\nv = base.dists.betaprime.variance( 2.0, NaN )\nv = base.dists.betaprime.variance( NaN, 3.0 )\n",
- "base.dists.binomial.Binomial": "binomial = base.dists.binomial.Binomial( 8, 0.5 );\nbinomial.n\nbinomial.p\nbinomial.kurtosis\nbinomial.mean\nbinomial.median\nbinomial.mode\nbinomial.skewness\nbinomial.stdev\nbinomial.variance\nbinomial.cdf( 2.9 )\nbinomial.logpmf( 3.0 )\nbinomial.mgf( 0.2 )\nbinomial.pmf( 3.0 )\nbinomial.quantile( 0.8 )\n",
- "base.dists.binomial.cdf": "y = base.dists.binomial.cdf( 3.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 21.0, 20, 0.2 )\ny = base.dists.binomial.cdf( 5.0, 10, 0.4 )\ny = base.dists.binomial.cdf( 0.0, 10, 0.4 )\ny = base.dists.binomial.cdf( NaN, 20, 0.5 )\ny = base.dists.binomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.cdf( 0.0, 20, NaN )\ny = base.dists.binomial.cdf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.binomial.cdf( 2.0, 20, 1.5 )\n",
- "base.dists.binomial.entropy": "v = base.dists.binomial.entropy( 100, 0.1 )\nv = base.dists.binomial.entropy( 20, 0.5 )\nv = base.dists.binomial.entropy( 10.3, 0.5 )\nv = base.dists.binomial.entropy( 20, 1.1 )\nv = base.dists.binomial.entropy( 20, NaN )\n",
- "base.dists.binomial.kurtosis": "v = base.dists.binomial.kurtosis( 100, 0.1 )\nv = base.dists.binomial.kurtosis( 20, 0.5 )\nv = base.dists.binomial.kurtosis( 10.3, 0.5 )\nv = base.dists.binomial.kurtosis( 20, 1.1 )\nv = base.dists.binomial.kurtosis( 20, NaN )\n",
- "base.dists.binomial.logpmf": "y = base.dists.binomial.logpmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.logpmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.logpmf( NaN, 20, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.logpmf( 0.0, 20, NaN )\ny = base.dists.binomial.logpmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.logpmf( 2.0, 20, 1.5 )\n",
- "base.dists.binomial.mean": "v = base.dists.binomial.mean( 100, 0.1 )\nv = base.dists.binomial.mean( 20, 0.5 )\nv = base.dists.binomial.mean( 10.3, 0.5 )\nv = base.dists.binomial.mean( 20, 1.1 )\nv = base.dists.binomial.mean( 20, NaN )\n",
- "base.dists.binomial.median": "v = base.dists.binomial.median( 100, 0.1 )\nv = base.dists.binomial.median( 20, 0.5 )\nv = base.dists.binomial.median( 10.3, 0.5 )\nv = base.dists.binomial.median( 20, 1.1 )\nv = base.dists.binomial.median( 20, NaN )\n",
- "base.dists.binomial.mgf": "y = base.dists.binomial.mgf( 0.5, 20, 0.2 )\ny = base.dists.binomial.mgf( 5.0, 20, 0.2 )\ny = base.dists.binomial.mgf( 0.9, 10, 0.4 )\ny = base.dists.binomial.mgf( 0.0, 10, 0.4 )\ny = base.dists.binomial.mgf( NaN, 20, 0.5 )\ny = base.dists.binomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.mgf( 0.0, 20, NaN )\ny = base.dists.binomial.mgf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.mgf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.mgf( 2.0, 20, -1.0 )\ny = base.dists.binomial.mgf( 2.0, 20, 1.5 )\n",
- "base.dists.binomial.mode": "v = base.dists.binomial.mode( 100, 0.1 )\nv = base.dists.binomial.mode( 20, 0.5 )\nv = base.dists.binomial.mode( 10.3, 0.5 )\nv = base.dists.binomial.mode( 20, 1.1 )\nv = base.dists.binomial.mode( 20, NaN )\n",
- "base.dists.binomial.pmf": "y = base.dists.binomial.pmf( 3.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 21.0, 20, 0.2 )\ny = base.dists.binomial.pmf( 5.0, 10, 0.4 )\ny = base.dists.binomial.pmf( 0.0, 10, 0.4 )\ny = base.dists.binomial.pmf( NaN, 20, 0.5 )\ny = base.dists.binomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.binomial.pmf( 0.0, 20, NaN )\ny = base.dists.binomial.pmf( 2.0, 1.5, 0.5 )\ny = base.dists.binomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.binomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.binomial.pmf( 2.0, 20, 1.5 )\n",
- "base.dists.binomial.quantile": "y = base.dists.binomial.quantile( 0.4, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.8, 20, 0.2 )\ny = base.dists.binomial.quantile( 0.5, 10, 0.4 )\ny = base.dists.binomial.quantile( 0.0, 10, 0.4 )\ny = base.dists.binomial.quantile( 1.0, 10, 0.4 )\ny = base.dists.binomial.quantile( NaN, 20, 0.5 )\ny = base.dists.binomial.quantile( 0.2, NaN, 0.5 )\ny = base.dists.binomial.quantile( 0.2, 20, NaN )\ny = base.dists.binomial.quantile( 0.5, 1.5, 0.5 )\ny = base.dists.binomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.binomial.quantile( 0.5, 20, -1.0 )\ny = base.dists.binomial.quantile( 0.5, 20, 1.5 )\n",
- "base.dists.binomial.skewness": "v = base.dists.binomial.skewness( 100, 0.1 )\nv = base.dists.binomial.skewness( 20, 0.5 )\nv = base.dists.binomial.skewness( 10.3, 0.5 )\nv = base.dists.binomial.skewness( 20, 1.1 )\nv = base.dists.binomial.skewness( 20, NaN )\n",
- "base.dists.binomial.stdev": "v = base.dists.binomial.stdev( 100, 0.1 )\nv = base.dists.binomial.stdev( 20, 0.5 )\nv = base.dists.binomial.stdev( 10.3, 0.5 )\nv = base.dists.binomial.stdev( 20, 1.1 )\nv = base.dists.binomial.stdev( 20, NaN )\n",
- "base.dists.binomial.variance": "v = base.dists.binomial.variance( 100, 0.1 )\nv = base.dists.binomial.variance( 20, 0.5 )\nv = base.dists.binomial.variance( 10.3, 0.5 )\nv = base.dists.binomial.variance( 20, 1.1 )\nv = base.dists.binomial.variance( 20, NaN )\n",
- "base.dists.cauchy.Cauchy": "cauchy = base.dists.cauchy.Cauchy( 0.0, 1.0 );\ncauchy.x0\ncauchy.gamma\ncauchy.entropy\ncauchy.median\ncauchy.mode\ncauchy.cdf( 0.8 )\ncauchy.logcdf( 1.0 )\ncauchy.logpdf( 1.0 )\ncauchy.pdf( 1.0 )\ncauchy.quantile( 0.8 )\n",
- "base.dists.cauchy.cdf": "y = base.dists.cauchy.cdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.cdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.cdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.cdf( 1.0, NaN, 3.0 )\n",
- "base.dists.cauchy.entropy": "v = base.dists.cauchy.entropy( 10.0, 7.0 )\nv = base.dists.cauchy.entropy( 22.0, 0.5 )\nv = base.dists.cauchy.entropy( 10.3, -0.5 )\n",
- "base.dists.cauchy.logcdf": "y = base.dists.cauchy.logcdf( 4.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 3.0, 2.0 )\ny = base.dists.cauchy.logcdf( NaN, 0.0, 2.0 )\ny = base.dists.cauchy.logcdf( 1.0, 2.0, NaN )\ny = base.dists.cauchy.logcdf( 1.0, NaN, 3.0 )\n",
- "base.dists.cauchy.logpdf": "y = base.dists.cauchy.logpdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.logpdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.logpdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.logpdf( 2.0, 1.0, -2.0 )\n",
- "base.dists.cauchy.median": "v = base.dists.cauchy.median( 10.0, 5.0 )\nv = base.dists.cauchy.median( 7.0, 0.5 )\nv = base.dists.cauchy.median( 10.3, -0.5 )\n",
- "base.dists.cauchy.mode": "v = base.dists.cauchy.mode( 10.0, 5.0 )\nv = base.dists.cauchy.mode( 7.0, 0.5 )\nv = base.dists.cauchy.mode( 10.3, -0.5 )\n",
- "base.dists.cauchy.pdf": "y = base.dists.cauchy.pdf( 2.0, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 0.1 )\ny = base.dists.cauchy.pdf( 4.0, 3.0, 3.0 )\ny = base.dists.cauchy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, NaN, 1.0 )\ny = base.dists.cauchy.pdf( 2.0, 1.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.pdf( 2.0, 1.0, -2.0 )\n",
- "base.dists.cauchy.quantile": "y = base.dists.cauchy.quantile( 0.3, 2.0, 2.0 )\ny = base.dists.cauchy.quantile( 0.8, 10, 2.0 )\ny = base.dists.cauchy.quantile( 0.1, 10.0, 2.0 )\ny = base.dists.cauchy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cauchy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cauchy.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.chi.cdf": "y = base.dists.chi.cdf( 2.0, 3.0 )\ny = base.dists.chi.cdf( 1.0, 0.5 )\ny = base.dists.chi.cdf( -1.0, 4.0 )\ny = base.dists.chi.cdf( NaN, 1.0 )\ny = base.dists.chi.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.cdf( 2.0, 0.0 )\ny = base.dists.chi.cdf( -2.0, 0.0 )\ny = base.dists.chi.cdf( 0.0, 0.0 )\n",
- "base.dists.chi.Chi": "chi = base.dists.chi.Chi( 6.0 );\nchi.k\nchi.entropy\nchi.kurtosis\nchi.mean\nchi.mode\nchi.skewness\nchi.stdev\nchi.variance\nchi.cdf( 1.0 )\nchi.logpdf( 1.5 )\nchi.pdf( 1.5 )\nchi.quantile( 0.5 )\n",
- "base.dists.chi.entropy": "v = base.dists.chi.entropy( 11.0 )\nv = base.dists.chi.entropy( 1.5 )\n",
- "base.dists.chi.kurtosis": "v = base.dists.chi.kurtosis( 9.0 )\nv = base.dists.chi.kurtosis( 1.5 )\n",
- "base.dists.chi.logpdf": "y = base.dists.chi.logpdf( 0.3, 4.0 )\ny = base.dists.chi.logpdf( 0.7, 0.7 )\ny = base.dists.chi.logpdf( -1.0, 0.5 )\ny = base.dists.chi.logpdf( 0.0, NaN )\ny = base.dists.chi.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.logpdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.chi.mean": "v = base.dists.chi.mean( 11.0 )\nv = base.dists.chi.mean( 4.5 )\n",
- "base.dists.chi.mode": "v = base.dists.chi.mode( 11.0 )\nv = base.dists.chi.mode( 1.5 )\n",
- "base.dists.chi.pdf": "y = base.dists.chi.pdf( 0.3, 4.0 )\ny = base.dists.chi.pdf( 0.7, 0.7 )\ny = base.dists.chi.pdf( -1.0, 0.5 )\ny = base.dists.chi.pdf( 0.0, NaN )\ny = base.dists.chi.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chi.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chi.pdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.chi.quantile": "y = base.dists.chi.quantile( 0.8, 1.0 )\ny = base.dists.chi.quantile( 0.5, 4.0 )\ny = base.dists.chi.quantile( 0.8, 0.1 )\ny = base.dists.chi.quantile( -0.2, 0.5 )\ny = base.dists.chi.quantile( 1.1, 0.5 )\ny = base.dists.chi.quantile( NaN, 1.0 )\ny = base.dists.chi.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chi.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chi.quantile( 0.3, 0.0 )\ny = base.dists.chi.quantile( 0.9, 0.0 )\n",
- "base.dists.chi.skewness": "v = base.dists.chi.skewness( 11.0 )\nv = base.dists.chi.skewness( 1.5 )\n",
- "base.dists.chi.stdev": "v = base.dists.chi.stdev( 11.0 )\nv = base.dists.chi.stdev( 1.5 )\n",
- "base.dists.chi.variance": "v = base.dists.chi.variance( 11.0 )\nv = base.dists.chi.variance( 1.5 )\n",
- "base.dists.chisquare.cdf": "y = base.dists.chisquare.cdf( 2.0, 3.0 )\ny = base.dists.chisquare.cdf( 1.0, 0.5 )\ny = base.dists.chisquare.cdf( -1.0, 4.0 )\ny = base.dists.chisquare.cdf( NaN, 1.0 )\ny = base.dists.chisquare.cdf( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.cdf( 2.0, 0.0 )\ny = base.dists.chisquare.cdf( -2.0, 0.0 )\ny = base.dists.chisquare.cdf( 0.0, 0.0 )\n",
- "base.dists.chisquare.ChiSquare": "chisquare = base.dists.chisquare.ChiSquare( 6.0 );\nchisquare.k\nchisquare.entropy\nchisquare.kurtosis\nchisquare.mean\nchisquare.mode\nchisquare.skewness\nchisquare.stdev\nchisquare.variance\nchisquare.cdf( 3.0 )\nchisquare.mgf( 0.2 )\nchisquare.pdf( 1.5 )\nchisquare.quantile( 0.5 )\n",
- "base.dists.chisquare.entropy": "v = base.dists.chisquare.entropy( 11.0 )\nv = base.dists.chisquare.entropy( 1.5 )\n",
- "base.dists.chisquare.kurtosis": "v = base.dists.chisquare.kurtosis( 9.0 )\nv = base.dists.chisquare.kurtosis( 1.5 )\n",
- "base.dists.chisquare.logpdf": "y = base.dists.chisquare.logpdf( 0.3, 4.0 )\ny = base.dists.chisquare.logpdf( 0.7, 0.7 )\ny = base.dists.chisquare.logpdf( -1.0, 0.5 )\ny = base.dists.chisquare.logpdf( 0.0, NaN )\ny = base.dists.chisquare.logpdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.logpdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.logpdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.chisquare.mean": "v = base.dists.chisquare.mean( 11.0 )\nv = base.dists.chisquare.mean( 4.5 )\n",
- "base.dists.chisquare.mode": "v = base.dists.chisquare.mode( 11.0 )\nv = base.dists.chisquare.mode( 1.5 )\n",
- "base.dists.chisquare.pdf": "y = base.dists.chisquare.pdf( 0.3, 4.0 )\ny = base.dists.chisquare.pdf( 0.7, 0.7 )\ny = base.dists.chisquare.pdf( -1.0, 0.5 )\ny = base.dists.chisquare.pdf( 0.0, NaN )\ny = base.dists.chisquare.pdf( NaN, 2.0 )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.chisquare.pdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.chisquare.quantile": "y = base.dists.chisquare.quantile( 0.8, 1.0 )\ny = base.dists.chisquare.quantile( 0.5, 4.0 )\ny = base.dists.chisquare.quantile( 0.8, 0.1 )\ny = base.dists.chisquare.quantile( -0.2, 0.5 )\ny = base.dists.chisquare.quantile( 1.1, 0.5 )\ny = base.dists.chisquare.quantile( NaN, 1.0 )\ny = base.dists.chisquare.quantile( 0.0, NaN )\n\n// Negative degrees of freedom:\ny = base.dists.chisquare.quantile( 0.5, -1.0 )\n\n// Degenerate distribution when `k = 0`:\ny = base.dists.chisquare.quantile( 0.3, 0.0 )\ny = base.dists.chisquare.quantile( 0.9, 0.0 )\n",
- "base.dists.chisquare.skewness": "v = base.dists.chisquare.skewness( 11.0 )\nv = base.dists.chisquare.skewness( 1.5 )\n",
- "base.dists.chisquare.stdev": "v = base.dists.chisquare.stdev( 11.0 )\nv = base.dists.chisquare.stdev( 1.5 )\n",
- "base.dists.chisquare.variance": "v = base.dists.chisquare.variance( 11.0 )\nv = base.dists.chisquare.variance( 1.5 )\n",
- "base.dists.cosine.cdf": "y = base.dists.cosine.cdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.cdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.cdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.cdf( 10.0, 8.0, 0.0 )\n",
- "base.dists.cosine.Cosine": "cosine = base.dists.cosine.Cosine( -2.0, 3.0 );\ncosine.mu\ncosine.s\ncosine.kurtosis\ncosine.mean\ncosine.median\ncosine.mode\ncosine.skewness\ncosine.stdev\ncosine.variance\ncosine.cdf( 0.5 )\ncosine.logcdf( 0.5 )\ncosine.logpdf( -1.0 )\ncosine.mgf( 0.2 )\ncosine.pdf( -2.0 )\ncosine.quantile( 0.9 )\n",
- "base.dists.cosine.kurtosis": "y = base.dists.cosine.kurtosis( 0.0, 1.0 )\ny = base.dists.cosine.kurtosis( 4.0, 2.0 )\ny = base.dists.cosine.kurtosis( NaN, 1.0 )\ny = base.dists.cosine.kurtosis( 0.0, NaN )\ny = base.dists.cosine.kurtosis( 0.0, 0.0 )\n",
- "base.dists.cosine.logcdf": "y = base.dists.cosine.logcdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.logcdf( 2.0, 0.0, NaN )\ny = base.dists.cosine.logcdf( 2.0, NaN, 1.0 )\ny = base.dists.cosine.logcdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.cosine.logcdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 8.0, 8.0, 0.0 )\ny = base.dists.cosine.logcdf( 10.0, 8.0, 0.0 )\n",
- "base.dists.cosine.logpdf": "y = base.dists.cosine.logpdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.logpdf( -1.0, 2.0, 4.0 )\ny = base.dists.cosine.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.cosine.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.logpdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.cosine.mean": "y = base.dists.cosine.mean( 0.0, 1.0 )\ny = base.dists.cosine.mean( 4.0, 2.0 )\ny = base.dists.cosine.mean( NaN, 1.0 )\ny = base.dists.cosine.mean( 0.0, NaN )\ny = base.dists.cosine.mean( 0.0, 0.0 )\n",
- "base.dists.cosine.median": "y = base.dists.cosine.median( 0.0, 1.0 )\ny = base.dists.cosine.median( 4.0, 2.0 )\ny = base.dists.cosine.median( NaN, 1.0 )\ny = base.dists.cosine.median( 0.0, NaN )\ny = base.dists.cosine.median( 0.0, 0.0 )\n",
- "base.dists.cosine.mgf": "y = base.dists.cosine.mgf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.mgf( 9.0, 10.0, 3.0 )\ny = base.dists.cosine.mgf( 0.5, 0.0, NaN )\ny = base.dists.cosine.mgf( 0.5, NaN, 1.0 )\ny = base.dists.cosine.mgf( NaN, 0.0, 1.0 )\n",
- "base.dists.cosine.mode": "y = base.dists.cosine.mode( 0.0, 1.0 )\ny = base.dists.cosine.mode( 4.0, 2.0 )\ny = base.dists.cosine.mode( NaN, 1.0 )\ny = base.dists.cosine.mode( 0.0, NaN )\ny = base.dists.cosine.mode( 0.0, 0.0 )\n",
- "base.dists.cosine.pdf": "y = base.dists.cosine.pdf( 2.0, 0.0, 3.0 )\ny = base.dists.cosine.pdf( 2.4, 4.0, 2.0 )\ny = base.dists.cosine.pdf( NaN, 0.0, 1.0 )\ny = base.dists.cosine.pdf( 0.0, NaN, 1.0 )\ny = base.dists.cosine.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.cosine.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.cosine.pdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.cosine.quantile": "y = base.dists.cosine.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.cosine.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.cosine.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.cosine.quantile( NaN, 0.0, 1.0 )\ny = base.dists.cosine.quantile( 0.0, NaN, 1.0 )\ny = base.dists.cosine.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.cosine.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.cosine.skewness": "y = base.dists.cosine.skewness( 0.0, 1.0 )\ny = base.dists.cosine.skewness( 4.0, 2.0 )\ny = base.dists.cosine.skewness( NaN, 1.0 )\ny = base.dists.cosine.skewness( 0.0, NaN )\ny = base.dists.cosine.skewness( 0.0, 0.0 )\n",
- "base.dists.cosine.stdev": "y = base.dists.cosine.stdev( 0.0, 1.0 )\ny = base.dists.cosine.stdev( 4.0, 2.0 )\ny = base.dists.cosine.stdev( NaN, 1.0 )\ny = base.dists.cosine.stdev( 0.0, NaN )\ny = base.dists.cosine.stdev( 0.0, 0.0 )\n",
- "base.dists.cosine.variance": "y = base.dists.cosine.variance( 0.0, 1.0 )\ny = base.dists.cosine.variance( 4.0, 2.0 )\ny = base.dists.cosine.variance( NaN, 1.0 )\ny = base.dists.cosine.variance( 0.0, NaN )\ny = base.dists.cosine.variance( 0.0, 0.0 )\n",
- "base.dists.degenerate.cdf": "y = base.dists.degenerate.cdf( 2.0, 3.0 )\ny = base.dists.degenerate.cdf( 4.0, 3.0 )\ny = base.dists.degenerate.cdf( 3.0, 3.0 )\ny = base.dists.degenerate.cdf( NaN, 0.0 )\ny = base.dists.degenerate.cdf( 0.0, NaN )\n",
- "base.dists.degenerate.Degenerate": "degenerate = base.dists.degenerate.Degenerate( 2.0 );\ndegenerate.mu\ndegenerate.entropy\ndegenerate.mean\ndegenerate.mode\ndegenerate.median\ndegenerate.stdev\ndegenerate.variance\ndegenerate.cdf( 0.5 )\ndegenerate.logcdf( 2.5 )\ndegenerate.logpdf( 0.5 )\ndegenerate.logpmf( 2.5 )\ndegenerate.mgf( 0.2 )\ndegenerate.pdf( 2.0 )\ndegenerate.pmf( 2.0 )\ndegenerate.quantile( 0.7 )\n",
- "base.dists.degenerate.entropy": "v = base.dists.degenerate.entropy( 20.0 )\nv = base.dists.degenerate.entropy( -10.0 )\n",
- "base.dists.degenerate.logcdf": "y = base.dists.degenerate.logcdf( 2.0, 3.0 )\ny = base.dists.degenerate.logcdf( 4.0, 3.0 )\ny = base.dists.degenerate.logcdf( 3.0, 3.0 )\ny = base.dists.degenerate.logcdf( NaN, 0.0 )\ny = base.dists.degenerate.logcdf( 0.0, NaN )\n",
- "base.dists.degenerate.logpdf": "y = base.dists.degenerate.logpdf( 2.0, 3.0 )\ny = base.dists.degenerate.logpdf( 3.0, 3.0 )\ny = base.dists.degenerate.logpdf( NaN, 0.0 )\ny = base.dists.degenerate.logpdf( 0.0, NaN )\n",
- "base.dists.degenerate.logpmf": "y = base.dists.degenerate.logpmf( 2.0, 3.0 )\ny = base.dists.degenerate.logpmf( 3.0, 3.0 )\ny = base.dists.degenerate.logpmf( NaN, 0.0 )\ny = base.dists.degenerate.logpmf( 0.0, NaN )\n",
- "base.dists.degenerate.mean": "v = base.dists.degenerate.mean( 20.0 )\nv = base.dists.degenerate.mean( -10.0 )\n",
- "base.dists.degenerate.median": "v = base.dists.degenerate.median( 20.0 )\nv = base.dists.degenerate.median( -10.0 )\n",
- "base.dists.degenerate.mgf": "y = base.dists.degenerate.mgf( 1.0, 1.0 )\ny = base.dists.degenerate.mgf( 2.0, 3.0 )\ny = base.dists.degenerate.mgf( NaN, 0.0 )\ny = base.dists.degenerate.mgf( 0.0, NaN )\n",
- "base.dists.degenerate.mode": "v = base.dists.degenerate.mode( 20.0 )\nv = base.dists.degenerate.mode( -10.0 )\n",
- "base.dists.degenerate.pdf": "y = base.dists.degenerate.pdf( 2.0, 3.0 )\ny = base.dists.degenerate.pdf( 3.0, 3.0 )\ny = base.dists.degenerate.pdf( NaN, 0.0 )\ny = base.dists.degenerate.pdf( 0.0, NaN )\n",
- "base.dists.degenerate.pmf": "y = base.dists.degenerate.pmf( 2.0, 3.0 )\ny = base.dists.degenerate.pmf( 3.0, 3.0 )\ny = base.dists.degenerate.pmf( NaN, 0.0 )\ny = base.dists.degenerate.pmf( 0.0, NaN )\n",
- "base.dists.degenerate.quantile": "y = base.dists.degenerate.quantile( 0.5, 2.0 )\ny = base.dists.degenerate.quantile( 0.9, 4.0 )\ny = base.dists.degenerate.quantile( 1.1, 0.0 )\ny = base.dists.degenerate.quantile( -0.2, 0.0 )\ny = base.dists.degenerate.quantile( NaN, 0.0 )\ny = base.dists.degenerate.quantile( 0.0, NaN )\n",
- "base.dists.degenerate.stdev": "v = base.dists.degenerate.stdev( 20.0 )\nv = base.dists.degenerate.stdev( -10.0 )\n",
- "base.dists.degenerate.variance": "v = base.dists.degenerate.variance( 20.0 )\nv = base.dists.degenerate.variance( -10.0 )\n",
- "base.dists.discreteUniform.cdf": "y = base.dists.discreteUniform.cdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.cdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.cdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.cdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.cdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.cdf( 2.0, 1, 0 )\n",
- "base.dists.discreteUniform.DiscreteUniform": "discreteUniform = base.dists.discreteUniform.DiscreteUniform( -2, 2 );\ndiscreteUniform.a\ndiscreteUniform.b\ndiscreteUniform.entropy\ndiscreteUniform.kurtosis\ndiscreteUniform.mean\ndiscreteUniform.median\ndiscreteUniform.skewness\ndiscreteUniform.stdev\ndiscreteUniform.variance\ndiscreteUniform.cdf( 0.8 )\ndiscreteUniform.logcdf( 0.5 )\ndiscreteUniform.logpmf( 1.0 )\ndiscreteUniform.mgf( 0.8 )\ndiscreteUniform.pmf( 0.0 )\ndiscreteUniform.quantile( 0.8 )\n",
- "base.dists.discreteUniform.kurtosis": "v = base.dists.discreteUniform.kurtosis( 0, 1 )\nv = base.dists.discreteUniform.kurtosis( 4, 12 )\nv = base.dists.discreteUniform.kurtosis( -4, 8 )\n",
- "base.dists.discreteUniform.logcdf": "y = base.dists.discreteUniform.logcdf( 9.0, 0, 10 )\ny = base.dists.discreteUniform.logcdf( 0.5, 0, 2 )\ny = base.dists.discreteUniform.logcdf( PINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NINF, 2, 4 )\ny = base.dists.discreteUniform.logcdf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logcdf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logcdf( 2.0, 1, 0 )\n",
- "base.dists.discreteUniform.logpmf": "y = base.dists.discreteUniform.logpmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.logpmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.logpmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.logpmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.logpmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.logpmf( 2.0, 1, 2.4 )\n",
- "base.dists.discreteUniform.mean": "v = base.dists.discreteUniform.mean( -2, 2 )\nv = base.dists.discreteUniform.mean( 4, 12 )\nv = base.dists.discreteUniform.mean( 2, 8 )\n",
- "base.dists.discreteUniform.median": "v = base.dists.discreteUniform.median( -2, 2 )\nv = base.dists.discreteUniform.median( 4, 12 )\nv = base.dists.discreteUniform.median( 2, 8 )\n",
- "base.dists.discreteUniform.mgf": "y = base.dists.discreteUniform.mgf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.mgf( -0.2, 0, 4 )\ny = base.dists.discreteUniform.mgf( 2.0, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.5, 3, 2 )\ny = base.dists.discreteUniform.mgf( NaN, 0, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.mgf( 0.0, 0, NaN )\n",
- "base.dists.discreteUniform.pmf": "y = base.dists.discreteUniform.pmf( 2.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 5.0, 0, 4 )\ny = base.dists.discreteUniform.pmf( 3.0, -4, 4 )\ny = base.dists.discreteUniform.pmf( NaN, 0, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, NaN, 1 )\ny = base.dists.discreteUniform.pmf( 0.0, 0, NaN )\ny = base.dists.discreteUniform.pmf( 2.0, 3, 1 )\ny = base.dists.discreteUniform.pmf( 2.0, 1, 2.4 )\n",
- "base.dists.discreteUniform.quantile": "y = base.dists.discreteUniform.quantile( 0.8, 0, 1 )\ny = base.dists.discreteUniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.discreteUniform.quantile( 1.1, 0, 4 )\ny = base.dists.discreteUniform.quantile( -0.2, 0, 4 )\ny = base.dists.discreteUniform.quantile( NaN, -2, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, NaN, 2 )\ny = base.dists.discreteUniform.quantile( 0.1, -2, NaN )\ny = base.dists.discreteUniform.quantile( 0.5, 2, 1 )\n",
- "base.dists.discreteUniform.skewness": "v = base.dists.discreteUniform.skewness( -2, 2 )\nv = base.dists.discreteUniform.skewness( 4, 12 )\nv = base.dists.discreteUniform.skewness( 2, 8 )\n",
- "base.dists.discreteUniform.stdev": "v = base.dists.discreteUniform.stdev( 0, 1 )\nv = base.dists.discreteUniform.stdev( 4, 12 )\nv = base.dists.discreteUniform.stdev( 2, 8 )\n",
- "base.dists.discreteUniform.variance": "v = base.dists.discreteUniform.variance( 0, 1 )\nv = base.dists.discreteUniform.variance( 4, 12 )\nv = base.dists.discreteUniform.variance( 2, 8 )\n",
- "base.dists.erlang.cdf": "y = base.dists.erlang.cdf( 2.0, 1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 3, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 2.5, 1.0 )\ny = base.dists.erlang.cdf( -1.0, 2, 2.0 )\ny = base.dists.erlang.cdf( PINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NINF, 4, 2.0 )\ny = base.dists.erlang.cdf( NaN, 0, 1.0 )\ny = base.dists.erlang.cdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.cdf( 0.0, 0, NaN )\ny = base.dists.erlang.cdf( 2.0, -1, 1.0 )\ny = base.dists.erlang.cdf( 2.0, 1, -1.0 )\n",
- "base.dists.erlang.entropy": "v = base.dists.erlang.entropy( 1, 1.0 )\nv = base.dists.erlang.entropy( 4, 12.0 )\nv = base.dists.erlang.entropy( 8, 2.0 )\n",
- "base.dists.erlang.Erlang": "erlang = base.dists.erlang.Erlang( 6, 5.0 );\nerlang.k\nerlang.lambda\nerlang.entropy\nerlang.kurtosis\nerlang.mean\nerlang.mode\nerlang.skewness\nerlang.stdev\nerlang.variance\nerlang.cdf( 3.0 )\nerlang.logpdf( 3.0 )\nerlang.mgf( -0.5 )\nerlang.pdf( 3.0 )\nerlang.quantile( 0.8 )\n",
- "base.dists.erlang.kurtosis": "v = base.dists.erlang.kurtosis( 1, 1.0 )\nv = base.dists.erlang.kurtosis( 4, 12.0 )\nv = base.dists.erlang.kurtosis( 8, 2.0 )\n",
- "base.dists.erlang.logpdf": "y = base.dists.erlang.logpdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.logpdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.logpdf( NaN, 1, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.logpdf( 0.0, 1, NaN )\ny = base.dists.erlang.logpdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.logpdf( 2.0, 1, -1.0 )\n",
- "base.dists.erlang.mean": "v = base.dists.erlang.mean( 1, 1.0 )\nv = base.dists.erlang.mean( 4, 12.0 )\nv = base.dists.erlang.mean( 8, 2.0 )\n",
- "base.dists.erlang.mgf": "y = base.dists.erlang.mgf( 0.3, 1, 1.0 )\ny = base.dists.erlang.mgf( 2.0, 2, 3.0 )\ny = base.dists.erlang.mgf( -1.0, 2, 2.0 )\ny = base.dists.erlang.mgf( NaN, 1, 1.0 )\ny = base.dists.erlang.mgf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.mgf( 0.0, 1, NaN )\ny = base.dists.erlang.mgf( 0.2, -2, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 0.5, 0.5 )\ny = base.dists.erlang.mgf( 0.2, 1, 0.0 )\ny = base.dists.erlang.mgf( 0.2, 1, -5.0 )\n",
- "base.dists.erlang.mode": "v = base.dists.erlang.mode( 1, 1.0 )\nv = base.dists.erlang.mode( 4, 12.0 )\nv = base.dists.erlang.mode( 8, 2.0 )\n",
- "base.dists.erlang.pdf": "y = base.dists.erlang.pdf( 0.1, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.5, 2, 2.5 )\ny = base.dists.erlang.pdf( -1.0, 4, 2.0 )\ny = base.dists.erlang.pdf( NaN, 1, 1.0 )\ny = base.dists.erlang.pdf( 0.0, NaN, 1.0 )\ny = base.dists.erlang.pdf( 0.0, 1, NaN )\ny = base.dists.erlang.pdf( 2.0, -2, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.5, 0.5 )\ny = base.dists.erlang.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.erlang.pdf( 2.0, 1, 0.0 )\ny = base.dists.erlang.pdf( 2.0, 1, -1.0 )\n",
- "base.dists.erlang.quantile": "y = base.dists.erlang.quantile( 0.8, 2, 1.0 )\ny = base.dists.erlang.quantile( 0.5, 4, 2.0 )\ny = base.dists.erlang.quantile( 1.1, 1, 1.0 )\ny = base.dists.erlang.quantile( -0.2, 1, 1.0 )\ny = base.dists.erlang.quantile( NaN, 1, 1.0 )\ny = base.dists.erlang.quantile( 0.0, NaN, 1.0 )\ny = base.dists.erlang.quantile( 0.0, 1, NaN )\n\n// Non-integer shape parameter:\ny = base.dists.erlang.quantile( 0.5, 0.5, 1.0 )\n\n// Non-positive shape parameter:\ny = base.dists.erlang.quantile( 0.5, -1, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.erlang.quantile( 0.5, 1, -1.0 )\n",
- "base.dists.erlang.skewness": "v = base.dists.erlang.skewness( 1, 1.0 )\nv = base.dists.erlang.skewness( 4, 12.0 )\nv = base.dists.erlang.skewness( 8, 2.0 )\n",
- "base.dists.erlang.stdev": "v = base.dists.erlang.stdev( 1, 1.0 )\nv = base.dists.erlang.stdev( 4, 12.0 )\nv = base.dists.erlang.stdev( 8, 2.0 )\n",
- "base.dists.erlang.variance": "v = base.dists.erlang.variance( 1, 1.0 )\nv = base.dists.erlang.variance( 4, 12.0 )\nv = base.dists.erlang.variance( 8, 2.0 )\n",
- "base.dists.exponential.cdf": "y = base.dists.exponential.cdf( 2.0, 0.1 )\ny = base.dists.exponential.cdf( 1.0, 2.0 )\ny = base.dists.exponential.cdf( -1.0, 4.0 )\ny = base.dists.exponential.cdf( NaN, 1.0 )\ny = base.dists.exponential.cdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.cdf( 2.0, -1.0 )\n",
- "base.dists.exponential.entropy": "v = base.dists.exponential.entropy( 11.0 )\nv = base.dists.exponential.entropy( 4.5 )\n",
- "base.dists.exponential.Exponential": "exponential = base.dists.exponential.Exponential( 6.0 );\nexponential.lambda\nexponential.entropy\nexponential.kurtosis\nexponential.mean\nexponential.median\nexponential.mode\nexponential.skewness\nexponential.stdev\nexponential.variance\nexponential.cdf( 1.0 )\nexponential.logcdf( 1.0 )\nexponential.logpdf( 1.5 )\nexponential.mgf( -0.5 )\nexponential.pdf( 1.5 )\nexponential.quantile( 0.5 )\n",
- "base.dists.exponential.kurtosis": "v = base.dists.exponential.kurtosis( 11.0 )\nv = base.dists.exponential.kurtosis( 4.5 )\n",
- "base.dists.exponential.logcdf": "y = base.dists.exponential.logcdf( 2.0, 0.1 )\ny = base.dists.exponential.logcdf( 1.0, 2.0 )\ny = base.dists.exponential.logcdf( -1.0, 4.0 )\ny = base.dists.exponential.logcdf( NaN, 1.0 )\ny = base.dists.exponential.logcdf( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.logcdf( 2.0, -1.0 )\n",
- "base.dists.exponential.logpdf": "y = base.dists.exponential.logpdf( 0.3, 4.0 )\ny = base.dists.exponential.logpdf( 2.0, 0.7 )\ny = base.dists.exponential.logpdf( -1.0, 0.5 )\ny = base.dists.exponential.logpdf( 0, NaN )\ny = base.dists.exponential.logpdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.logpdf( 2.0, -1.0 )\n",
- "base.dists.exponential.mean": "v = base.dists.exponential.mean( 11.0 )\nv = base.dists.exponential.mean( 4.5 )\n",
- "base.dists.exponential.median": "v = base.dists.exponential.median( 11.0 )\nv = base.dists.exponential.median( 4.5 )\n",
- "base.dists.exponential.mode": "v = base.dists.exponential.mode( 11.0 )\nv = base.dists.exponential.mode( 4.5 )\n",
- "base.dists.exponential.pdf": "y = base.dists.exponential.pdf( 0.3, 4.0 )\ny = base.dists.exponential.pdf( 2.0, 0.7 )\ny = base.dists.exponential.pdf( -1.0, 0.5 )\ny = base.dists.exponential.pdf( 0, NaN )\ny = base.dists.exponential.pdf( NaN, 2.0 )\n\n// Negative rate:\ny = base.dists.exponential.pdf( 2.0, -1.0 )\n",
- "base.dists.exponential.quantile": "y = base.dists.exponential.quantile( 0.8, 1.0 )\ny = base.dists.exponential.quantile( 0.5, 4.0 )\ny = base.dists.exponential.quantile( 0.5, 0.1 )\ny = base.dists.exponential.quantile( -0.2, 0.1 )\ny = base.dists.exponential.quantile( NaN, 1.0 )\ny = base.dists.exponential.quantile( 0.0, NaN )\n\n// Negative rate parameter:\ny = base.dists.exponential.quantile( 0.5, -1.0 )\n",
- "base.dists.exponential.skewness": "v = base.dists.exponential.skewness( 11.0 )\nv = base.dists.exponential.skewness( 4.5 )\n",
- "base.dists.exponential.stdev": "v = base.dists.exponential.stdev( 9.0 )\nv = base.dists.exponential.stdev( 1.0 )\n",
- "base.dists.exponential.variance": "v = base.dists.exponential.variance( 9.0 )\nv = base.dists.exponential.variance( 1.0 )\n",
- "base.dists.f.cdf": "y = base.dists.f.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.f.cdf( 2.0, 8.0, 4.0 )\ny = base.dists.f.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.f.cdf( PINF, 4.0, 2.0 )\ny = base.dists.f.cdf( NINF, 4.0, 2.0 )\ny = base.dists.f.cdf( NaN, 1.0, 1.0 )\ny = base.dists.f.cdf( 0.0, NaN, 1.0 )\ny = base.dists.f.cdf( 0.0, 1.0, NaN )\ny = base.dists.f.cdf( 2.0, 1.0, -1.0 )\ny = base.dists.f.cdf( 2.0, -1.0, 1.0 )\n",
- "base.dists.f.entropy": "v = base.dists.f.entropy( 3.0, 7.0 )\nv = base.dists.f.entropy( 4.0, 12.0 )\nv = base.dists.f.entropy( 8.0, 2.0 )\n",
- "base.dists.f.F": "f = base.dists.f.F( 6.0, 9.0 );\nf.d1\nf.d2\nf.entropy\nf.kurtosis\nf.mean\nf.mode\nf.skewness\nf.stdev\nf.variance\nf.cdf( 3.0 )\nf.pdf( 2.5 )\nf.quantile( 0.8 )\n",
- "base.dists.f.kurtosis": "v = base.dists.f.kurtosis( 3.0, 9.0 )\nv = base.dists.f.kurtosis( 4.0, 12.0 )\nv = base.dists.f.kurtosis( 8.0, 9.0 )\n",
- "base.dists.f.mean": "v = base.dists.f.mean( 3.0, 5.0 )\nv = base.dists.f.mean( 4.0, 12.0 )\nv = base.dists.f.mean( 8.0, 4.0 )\n",
- "base.dists.f.mode": "v = base.dists.f.mode( 3.0, 5.0 )\nv = base.dists.f.mode( 4.0, 12.0 )\nv = base.dists.f.mode( 8.0, 4.0 )\n",
- "base.dists.f.pdf": "y = base.dists.f.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.f.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.f.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.f.pdf( NaN, 1.0, 1.0 )\ny = base.dists.f.pdf( 0.0, NaN, 1.0 )\ny = base.dists.f.pdf( 0.0, 1.0, NaN )\ny = base.dists.f.pdf( 2.0, 1.0, -1.0 )\ny = base.dists.f.pdf( 2.0, -1.0, 1.0 )\n",
- "base.dists.f.quantile": "y = base.dists.f.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.f.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.f.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.f.quantile( NaN, 1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, NaN, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, NaN )\ny = base.dists.f.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.f.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.f.skewness": "v = base.dists.f.skewness( 3.0, 7.0 )\nv = base.dists.f.skewness( 4.0, 12.0 )\nv = base.dists.f.skewness( 8.0, 7.0 )\n",
- "base.dists.f.stdev": "v = base.dists.f.stdev( 3.0, 5.0 )\nv = base.dists.f.stdev( 4.0, 12.0 )\nv = base.dists.f.stdev( 8.0, 5.0 )\n",
- "base.dists.f.variance": "v = base.dists.f.variance( 3.0, 5.0 )\nv = base.dists.f.variance( 4.0, 12.0 )\nv = base.dists.f.variance( 8.0, 5.0 )\n",
- "base.dists.frechet.cdf": "y = base.dists.frechet.cdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.cdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.cdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.cdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.cdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.cdf( 0.0, 1.0, -1.0, 0.0 )\n",
- "base.dists.frechet.entropy": "y = base.dists.frechet.entropy( 1.0, 1.0, 1.0 )\ny = base.dists.frechet.entropy( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.entropy( NaN, 1.0, 0.0 )\ny = base.dists.frechet.entropy( 1.0, NaN, 0.0 )\ny = base.dists.frechet.entropy( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.Frechet": "frechet = base.dists.frechet.Frechet( 1.0, 1.0, 0.0 );\nfrechet.alpha\nfrechet.s\nfrechet.m\nfrechet.entropy\nfrechet.kurtosis\nfrechet.mean\nfrechet.median\nfrechet.mode\nfrechet.skewness\nfrechet.stdev\nfrechet.variance\nfrechet.cdf( 0.8 )\nfrechet.logcdf( 0.8 )\nfrechet.logpdf( 0.8 )\nfrechet.pdf( 0.8 )\nfrechet.quantile( 0.8 )\n",
- "base.dists.frechet.kurtosis": "y = base.dists.frechet.kurtosis( 5.0, 2.0, 1.0 )\ny = base.dists.frechet.kurtosis( 5.0, 10.0, -3.0 )\ny = base.dists.frechet.kurtosis( 3.5, 2.0, 1.0 )\ny = base.dists.frechet.kurtosis( NaN, 1.0, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, NaN, 0.0 )\ny = base.dists.frechet.kurtosis( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.logcdf": "y = base.dists.frechet.logcdf( 10.0, 2.0, 3.0, 0.0 )\ny = base.dists.frechet.logcdf( -1.0, 2.0, 3.0, -3.0 )\ny = base.dists.frechet.logcdf( 2.5, 2.0, 1.0, 2.0 )\ny = base.dists.frechet.logcdf( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, NaN, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.logcdf( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.logcdf( 0.0, 1.0, -1.0, 0.0 )\n",
- "base.dists.frechet.logpdf": "y = base.dists.frechet.logpdf( 10.0, 1.0, 3.0, 5.0 )\ny = base.dists.frechet.logpdf( -2.0, 1.0, 3.0, -3.0 )\ny = base.dists.frechet.logpdf( 0.0, 2.0, 1.0, -1.0 )\ny = base.dists.frechet.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.logpdf( 0.0, 0.0, -1.0 )\n",
- "base.dists.frechet.mean": "y = base.dists.frechet.mean( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.mean( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mean( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mean( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mean( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.median": "y = base.dists.frechet.median( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.median( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.median( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.median( NaN, 1.0, 0.0 )\ny = base.dists.frechet.median( 1.0, NaN, 0.0 )\ny = base.dists.frechet.median( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.mode": "y = base.dists.frechet.mode( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.mode( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.mode( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.mode( NaN, 1.0, 0.0 )\ny = base.dists.frechet.mode( 1.0, NaN, 0.0 )\ny = base.dists.frechet.mode( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.pdf": "y = base.dists.frechet.pdf( 10.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( -2.0, 0.0, 3.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.frechet.pdf( NaN, 0.0, 1.0 )\ny = base.dists.frechet.pdf( 0.0, NaN, 1.0 )\ny = base.dists.frechet.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.frechet.pdf( 0.0, 0.0, -1.0 )\n",
- "base.dists.frechet.quantile": "y = base.dists.frechet.quantile( 0.3, 10.0, 2.0, 3.0 )\ny = base.dists.frechet.quantile( 0.2, 3.0, 3.0, 3.0 )\ny = base.dists.frechet.quantile( 0.9, 1.0, 1.0, -3.0 )\ny = base.dists.frechet.quantile( NaN, 1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, NaN, 1.0, 0.0)\ny = base.dists.frechet.quantile( 0.0, 1.0, NaN, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, 1.0, NaN )\ny = base.dists.frechet.quantile( 0.0, -1.0, 1.0, 0.0 )\ny = base.dists.frechet.quantile( 0.0, 1.0, -1.0, 0.0 )\n",
- "base.dists.frechet.skewness": "y = base.dists.frechet.skewness( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.skewness( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.skewness( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.skewness( NaN, 1.0, 0.0 )\ny = base.dists.frechet.skewness( 1.0, NaN, 0.0 )\ny = base.dists.frechet.skewness( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.stdev": "y = base.dists.frechet.stdev( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.stdev( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.stdev( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.stdev( NaN, 1.0, 0.0 )\ny = base.dists.frechet.stdev( 1.0, NaN, 0.0 )\ny = base.dists.frechet.stdev( 1.0, 1.0, NaN )\n",
- "base.dists.frechet.variance": "y = base.dists.frechet.variance( 4.0, 2.0, 1.0 )\ny = base.dists.frechet.variance( 4.0, 2.0, -3.0 )\ny = base.dists.frechet.variance( 0.5, 2.0, 1.0 )\ny = base.dists.frechet.variance( NaN, 1.0, 0.0 )\ny = base.dists.frechet.variance( 1.0, NaN, 0.0 )\ny = base.dists.frechet.variance( 1.0, 1.0, NaN )\n",
- "base.dists.gamma.cdf": "y = base.dists.gamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.gamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.gamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.gamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.gamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.gamma.cdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0` when `α = 0.0`:\ny = base.dists.gamma.cdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( -2.0, 0.0, 2.0 )\ny = base.dists.gamma.cdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.gamma.entropy": "v = base.dists.gamma.entropy( 1.0, 1.0 )\nv = base.dists.gamma.entropy( 4.0, 12.0 )\nv = base.dists.gamma.entropy( 8.0, 2.0 )\n",
- "base.dists.gamma.Gamma": "gamma = base.dists.gamma.Gamma( 6.0, 5.0 );\ngamma.alpha\ngamma.beta\ngamma.entropy\ngamma.kurtosis\ngamma.mean\ngamma.mode\ngamma.skewness\ngamma.stdev\ngamma.variance\ngamma.cdf( 0.8 )\ngamma.logpdf( 1.0 )\ngamma.mgf( -0.5 )\ngamma.pdf( 1.0 )\ngamma.quantile( 0.8 )\n",
- "base.dists.gamma.kurtosis": "v = base.dists.gamma.kurtosis( 1.0, 1.0 )\nv = base.dists.gamma.kurtosis( 4.0, 12.0 )\nv = base.dists.gamma.kurtosis( 8.0, 2.0 )\n",
- "base.dists.gamma.logpdf": "y = base.dists.gamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.logpdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.logpdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.logpdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.gamma.mean": "v = base.dists.gamma.mean( 1.0, 1.0 )\nv = base.dists.gamma.mean( 4.0, 12.0 )\nv = base.dists.gamma.mean( 8.0, 2.0 )\n",
- "base.dists.gamma.mgf": "y = base.dists.gamma.mgf( 0.5, 0.5, 1.0 )\ny = base.dists.gamma.mgf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.mgf( NaN, 1.0, 1.0 )\ny = base.dists.gamma.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.mgf( 0.0, 1.0, NaN )\ny = base.dists.gamma.mgf( 2.0, 4.0, 1.0 )\ny = base.dists.gamma.mgf( 2.0, -0.5, 1.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, 0.0 )\ny = base.dists.gamma.mgf( 2.0, 1.0, -1.0 )\n",
- "base.dists.gamma.mode": "v = base.dists.gamma.mode( 1.0, 1.0 )\nv = base.dists.gamma.mode( 4.0, 12.0 )\nv = base.dists.gamma.mode( 8.0, 2.0 )\n",
- "base.dists.gamma.pdf": "y = base.dists.gamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.gamma.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.gamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.gamma.pdf( NaN, 0.6, 1.0 )\ny = base.dists.gamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.gamma.pdf( 2.0, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.pdf( 2.0, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.pdf( 2.0, 0.0, 2.0 )\ny = base.dists.gamma.pdf( 0.0, 0.0, 2.0 )\n",
- "base.dists.gamma.quantile": "y = base.dists.gamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.gamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.gamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.gamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.gamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.gamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.gamma.quantile( 0.5, 1.0, -1.0 )\n\n// Degenerate distribution centered at `0.0` when `α = 0.0`:\ny = base.dists.gamma.quantile( 0.3, 0.0, 2.0 )\ny = base.dists.gamma.quantile( 0.9, 0.0, 2.0 )\n",
- "base.dists.gamma.skewness": "v = base.dists.gamma.skewness( 1.0, 1.0 )\nv = base.dists.gamma.skewness( 4.0, 12.0 )\nv = base.dists.gamma.skewness( 8.0, 2.0 )\n",
- "base.dists.gamma.stdev": "v = base.dists.gamma.stdev( 1.0, 1.0 )\nv = base.dists.gamma.stdev( 4.0, 12.0 )\nv = base.dists.gamma.stdev( 8.0, 2.0 )\n",
- "base.dists.gamma.variance": "v = base.dists.gamma.variance( 1.0, 1.0 )\nv = base.dists.gamma.variance( 4.0, 12.0 )\nv = base.dists.gamma.variance( 8.0, 2.0 )\n",
- "base.dists.geometric.cdf": "y = base.dists.geometric.cdf( 2.0, 0.5 )\ny = base.dists.geometric.cdf( 2.0, 0.1 )\ny = base.dists.geometric.cdf( -1.0, 4.0 )\ny = base.dists.geometric.cdf( NaN, 0.5 )\ny = base.dists.geometric.cdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.cdf( 2.0, 1.4 )\n",
- "base.dists.geometric.entropy": "v = base.dists.geometric.entropy( 0.1 )\nv = base.dists.geometric.entropy( 0.5 )\n",
- "base.dists.geometric.Geometric": "geometric = base.dists.geometric.Geometric( 0.6 );\ngeometric.p\ngeometric.entropy\ngeometric.kurtosis\ngeometric.mean\ngeometric.median\ngeometric.mode\ngeometric.skewness\ngeometric.stdev\ngeometric.variance\ngeometric.cdf( 3.0 )\ngeometric.logcdf( 3.0 )\ngeometric.logpmf( 4.0 )\ngeometric.mgf( 0.5 )\ngeometric.pmf( 2.0 )\ngeometric.quantile( 0.7 )\n",
- "base.dists.geometric.kurtosis": "v = base.dists.geometric.kurtosis( 0.1 )\nv = base.dists.geometric.kurtosis( 0.5 )\n",
- "base.dists.geometric.logcdf": "y = base.dists.geometric.logcdf( 2.0, 0.5 )\ny = base.dists.geometric.logcdf( 2.0, 0.1 )\ny = base.dists.geometric.logcdf( -1.0, 4.0 )\ny = base.dists.geometric.logcdf( NaN, 0.5 )\ny = base.dists.geometric.logcdf( 0.0, NaN )\n\n// Invalid probability\ny = base.dists.geometric.logcdf( 2.0, 1.4 )\n",
- "base.dists.geometric.logpmf": "y = base.dists.geometric.logpmf( 4.0, 0.3 )\ny = base.dists.geometric.logpmf( 2.0, 0.7 )\ny = base.dists.geometric.logpmf( -1.0, 0.5 )\ny = base.dists.geometric.logpmf( 0.0, NaN )\ny = base.dists.geometric.logpmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.logpmf( 2.0, 1.5 )\n",
- "base.dists.geometric.mean": "v = base.dists.geometric.mean( 0.1 )\nv = base.dists.geometric.mean( 0.5 )\n",
- "base.dists.geometric.median": "v = base.dists.geometric.median( 0.1 )\nv = base.dists.geometric.median( 0.5 )\n",
- "base.dists.geometric.mgf": "y = base.dists.geometric.mgf( 0.2, 0.5 )\ny = base.dists.geometric.mgf( 0.4, 0.5 )\n\n// Case: t >= -ln(1-p)\ny = base.dists.geometric.mgf( 0.8, 0.5 )\ny = base.dists.geometric.mgf( NaN, 0.0 )\ny = base.dists.geometric.mgf( 0.0, NaN )\ny = base.dists.geometric.mgf( -2.0, -1.0 )\ny = base.dists.geometric.mgf( 0.2, 2.0 )\n",
- "base.dists.geometric.mode": "v = base.dists.geometric.mode( 0.1 )\nv = base.dists.geometric.mode( 0.5 )\n",
- "base.dists.geometric.pmf": "y = base.dists.geometric.pmf( 4.0, 0.3 )\ny = base.dists.geometric.pmf( 2.0, 0.7 )\ny = base.dists.geometric.pmf( -1.0, 0.5 )\ny = base.dists.geometric.pmf( 0.0, NaN )\ny = base.dists.geometric.pmf( NaN, 0.5 )\n\n// Invalid success probability:\ny = base.dists.geometric.pmf( 2.0, 1.5 )\n",
- "base.dists.geometric.quantile": "y = base.dists.geometric.quantile( 0.8, 0.4 )\ny = base.dists.geometric.quantile( 0.5, 0.4 )\ny = base.dists.geometric.quantile( 0.9, 0.1 )\ny = base.dists.geometric.quantile( -0.2, 0.1 )\ny = base.dists.geometric.quantile( NaN, 0.8 )\ny = base.dists.geometric.quantile( 0.4, NaN )\ny = base.dists.geometric.quantile( 0.5, -1.0 )\ny = base.dists.geometric.quantile( 0.5, 1.5 )\n",
- "base.dists.geometric.skewness": "v = base.dists.geometric.skewness( 0.1 )\nv = base.dists.geometric.skewness( 0.5 )\n",
- "base.dists.geometric.stdev": "v = base.dists.geometric.stdev( 0.1 )\nv = base.dists.geometric.stdev( 0.5 )\n",
- "base.dists.geometric.variance": "v = base.dists.geometric.variance( 0.1 )\nv = base.dists.geometric.variance( 0.5 )\n",
- "base.dists.gumbel.cdf": "y = base.dists.gumbel.cdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.cdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.cdf( 0.0, 0.0, -1.0 )\n",
- "base.dists.gumbel.entropy": "y = base.dists.gumbel.entropy( 0.0, 1.0 )\ny = base.dists.gumbel.entropy( 4.0, 2.0 )\ny = base.dists.gumbel.entropy( NaN, 1.0 )\ny = base.dists.gumbel.entropy( 0.0, NaN )\ny = base.dists.gumbel.entropy( 0.0, 0.0 )\n",
- "base.dists.gumbel.Gumbel": "gumbel = base.dists.gumbel.Gumbel( -2.0, 3.0 );\ngumbel.mu\ngumbel.beta\ngumbel.entropy\ngumbel.kurtosis\ngumbel.mean\ngumbel.median\ngumbel.mode\ngumbel.skewness\ngumbel.stdev\ngumbel.variance\ngumbel.cdf( 0.8 )\ngumbel.logcdf( 0.8 )\ngumbel.logpdf( 1.0 )\ngumbel.mgf( 0.2 )\ngumbel.pdf( 1.0 )\ngumbel.quantile( 0.8 )\n",
- "base.dists.gumbel.kurtosis": "y = base.dists.gumbel.kurtosis( 0.0, 1.0 )\ny = base.dists.gumbel.kurtosis( 4.0, 2.0 )\ny = base.dists.gumbel.kurtosis( NaN, 1.0 )\ny = base.dists.gumbel.kurtosis( 0.0, NaN )\ny = base.dists.gumbel.kurtosis( 0.0, 0.0 )\n",
- "base.dists.gumbel.logcdf": "y = base.dists.gumbel.logcdf( 10.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( -2.0, 0.0, 3.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logcdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logcdf( 0.0, 0.0, -1.0 )\n",
- "base.dists.gumbel.logpdf": "y = base.dists.gumbel.logpdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.logpdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.gumbel.mean": "y = base.dists.gumbel.mean( 0.0, 1.0 )\ny = base.dists.gumbel.mean( 4.0, 2.0 )\ny = base.dists.gumbel.mean( NaN, 1.0 )\ny = base.dists.gumbel.mean( 0.0, NaN )\ny = base.dists.gumbel.mean( 0.0, 0.0 )\n",
- "base.dists.gumbel.median": "y = base.dists.gumbel.median( 0.0, 1.0 )\ny = base.dists.gumbel.median( 4.0, 2.0 )\ny = base.dists.gumbel.median( NaN, 1.0 )\ny = base.dists.gumbel.median( 0.0, NaN )\ny = base.dists.gumbel.median( 0.0, 0.0 )\n",
- "base.dists.gumbel.mgf": "y = base.dists.gumbel.mgf( -1.0, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.1, 0.0, 3.0 )\ny = base.dists.gumbel.mgf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.mgf( 0.0, 0.0, NaN )\n\n// Case: `t >= 1/beta`\ny = base.dists.gumbel.mgf( 0.8, 0.0, 2.0 )\n\n// Non-positive scale parameter:\ny = base.dists.gumbel.mgf( 0.0, 0.0, -1.0 )\n",
- "base.dists.gumbel.mode": "y = base.dists.gumbel.mode( 0.0, 1.0 )\ny = base.dists.gumbel.mode( 4.0, 2.0 )\ny = base.dists.gumbel.mode( NaN, 1.0 )\ny = base.dists.gumbel.mode( 0.0, NaN )\ny = base.dists.gumbel.mode( 0.0, 0.0 )\n",
- "base.dists.gumbel.pdf": "y = base.dists.gumbel.pdf( 0.0, 0.0, 2.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 1.0, 3.0, 2.0 )\ny = base.dists.gumbel.pdf( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.pdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.gumbel.quantile": "y = base.dists.gumbel.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.gumbel.quantile( 0.5, 4.0, 4.0 )\ny = base.dists.gumbel.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( NaN, 0.0, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, NaN, 1.0 )\ny = base.dists.gumbel.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.gumbel.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.gumbel.skewness": "y = base.dists.gumbel.skewness( 0.0, 1.0 )\ny = base.dists.gumbel.skewness( 4.0, 2.0 )\ny = base.dists.gumbel.skewness( NaN, 1.0 )\ny = base.dists.gumbel.skewness( 0.0, NaN )\ny = base.dists.gumbel.skewness( 0.0, 0.0 )\n",
- "base.dists.gumbel.stdev": "y = base.dists.gumbel.stdev( 0.0, 1.0 )\ny = base.dists.gumbel.stdev( 4.0, 2.0 )\ny = base.dists.gumbel.stdev( NaN, 1.0 )\ny = base.dists.gumbel.stdev( 0.0, NaN )\ny = base.dists.gumbel.stdev( 0.0, 0.0 )\n",
- "base.dists.gumbel.variance": "y = base.dists.gumbel.variance( 0.0, 1.0 )\ny = base.dists.gumbel.variance( 4.0, 2.0 )\ny = base.dists.gumbel.variance( NaN, 1.0 )\ny = base.dists.gumbel.variance( 0.0, NaN )\ny = base.dists.gumbel.variance( 0.0, 0.0 )\n",
- "base.dists.hypergeometric.cdf": "y = base.dists.hypergeometric.cdf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.cdf( 0, 8, 4, 2)\ny = base.dists.hypergeometric.cdf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.cdf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.cdf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 1.5, 2 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.cdf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.cdf( 2.0, 8, 3, 9 )\n",
- "base.dists.hypergeometric.Hypergeometric": "hypergeometric = base.dists.hypergeometric.Hypergeometric( 100, 70, 20 );\nhypergeometric.N\nhypergeometric.K\nhypergeometric.n\nhypergeometric.kurtosis\nhypergeometric.mean\nhypergeometric.mode\nhypergeometric.skewness\nhypergeometric.stdev\nhypergeometric.variance\nhypergeometric.cdf( 2.9 )\nhypergeometric.logpmf( 10 )\nhypergeometric.pmf( 10 )\nhypergeometric.quantile( 0.8 )\n",
- "base.dists.hypergeometric.kurtosis": "v = base.dists.hypergeometric.kurtosis( 16, 11, 4 )\nv = base.dists.hypergeometric.kurtosis( 4, 2, 2 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 12 )\nv = base.dists.hypergeometric.kurtosis( 10.3, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5.5, 4 )\nv = base.dists.hypergeometric.kurtosis( 10, 5, 4.5 )\nv = base.dists.hypergeometric.kurtosis( NaN, 10, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, NaN, 4 )\nv = base.dists.hypergeometric.kurtosis( 20, 10, NaN )\n",
- "base.dists.hypergeometric.logpmf": "y = base.dists.hypergeometric.logpmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.logpmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.logpmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.logpmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.logpmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.logpmf( 2.0, 8, 3, 9 )\n",
- "base.dists.hypergeometric.mean": "v = base.dists.hypergeometric.mean( 16, 11, 4 )\nv = base.dists.hypergeometric.mean( 2, 1, 1 )\nv = base.dists.hypergeometric.mean( 10, 5, 12 )\nv = base.dists.hypergeometric.mean( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mean( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mean( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mean( NaN, 10, 4 )\nv = base.dists.hypergeometric.mean( 20, NaN, 4 )\nv = base.dists.hypergeometric.mean( 20, 10, NaN )\n",
- "base.dists.hypergeometric.mode": "v = base.dists.hypergeometric.mode( 16, 11, 4 )\nv = base.dists.hypergeometric.mode( 2, 1, 1 )\nv = base.dists.hypergeometric.mode( 10, 5, 12 )\nv = base.dists.hypergeometric.mode( 10.3, 10, 4 )\nv = base.dists.hypergeometric.mode( 10, 5.5, 4 )\nv = base.dists.hypergeometric.mode( 10, 5, 4.5 )\nv = base.dists.hypergeometric.mode( NaN, 10, 4 )\nv = base.dists.hypergeometric.mode( 20, NaN, 4 )\nv = base.dists.hypergeometric.mode( 20, 10, NaN )\n",
- "base.dists.hypergeometric.pmf": "y = base.dists.hypergeometric.pmf( 1.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( 1.5, 8, 4, 2 )\ny = base.dists.hypergeometric.pmf( NaN, 10, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, NaN, 5, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, NaN, 2 )\ny = base.dists.hypergeometric.pmf( 0.0, 10, 5, NaN )\ny = base.dists.hypergeometric.pmf( 2.0, 10.5, 5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 5, 1.5, 2 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, -2.0 )\ny = base.dists.hypergeometric.pmf( 2.0, 10, 5, 12 )\ny = base.dists.hypergeometric.pmf( 2.0, 8, 3, 9 )\n",
- "base.dists.hypergeometric.quantile": "y = base.dists.hypergeometric.quantile( 0.4, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.8, 60, 40, 20 )\ny = base.dists.hypergeometric.quantile( 0.5, 100, 10, 10 )\ny = base.dists.hypergeometric.quantile( 0.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( 1.0, 100, 40, 20 )\ny = base.dists.hypergeometric.quantile( NaN, 40, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, NaN, 20, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, NaN, 10 )\ny = base.dists.hypergeometric.quantile( 0.2, 40, 20, NaN )\n",
- "base.dists.hypergeometric.skewness": "v = base.dists.hypergeometric.skewness( 16, 11, 4 )\nv = base.dists.hypergeometric.skewness( 4, 2, 2 )\nv = base.dists.hypergeometric.skewness( 10, 5, 12 )\nv = base.dists.hypergeometric.skewness( 10.3, 10, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5.5, 4 )\nv = base.dists.hypergeometric.skewness( 10, 5, 4.5 )\nv = base.dists.hypergeometric.skewness( NaN, 10, 4 )\nv = base.dists.hypergeometric.skewness( 20, NaN, 4 )\nv = base.dists.hypergeometric.skewness( 20, 10, NaN )\n",
- "base.dists.hypergeometric.stdev": "v = base.dists.hypergeometric.stdev( 16, 11, 4 )\nv = base.dists.hypergeometric.stdev( 2, 1, 1 )\nv = base.dists.hypergeometric.stdev( 10, 5, 12 )\nv = base.dists.hypergeometric.stdev( 10.3, 10, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5.5, 4 )\nv = base.dists.hypergeometric.stdev( 10, 5, 4.5 )\nv = base.dists.hypergeometric.stdev( NaN, 10, 4 )\nv = base.dists.hypergeometric.stdev( 20, NaN, 4 )\nv = base.dists.hypergeometric.stdev( 20, 10, NaN )\n",
- "base.dists.hypergeometric.variance": "v = base.dists.hypergeometric.variance( 16, 11, 4 )\nv = base.dists.hypergeometric.variance( 2, 1, 1 )\nv = base.dists.hypergeometric.variance( 10, 5, 12 )\nv = base.dists.hypergeometric.variance( 10.3, 10, 4 )\nv = base.dists.hypergeometric.variance( 10, 5.5, 4 )\nv = base.dists.hypergeometric.variance( 10, 5, 4.5 )\nv = base.dists.hypergeometric.variance( NaN, 10, 4 )\nv = base.dists.hypergeometric.variance( 20, NaN, 4 )\nv = base.dists.hypergeometric.variance( 20, 10, NaN )\n",
- "base.dists.invgamma.cdf": "y = base.dists.invgamma.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 3.0, 1.0 )\ny = base.dists.invgamma.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.invgamma.cdf( PINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NINF, 4.0, 2.0 )\ny = base.dists.invgamma.cdf( NaN, 0.0, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.cdf( 0.0, 0.0, NaN )\ny = base.dists.invgamma.cdf( 2.0, -1.0, 1.0 )\ny = base.dists.invgamma.cdf( 2.0, 1.0, -1.0 )\n",
- "base.dists.invgamma.entropy": "v = base.dists.invgamma.entropy( 1.0, 1.0 )\nv = base.dists.invgamma.entropy( 4.0, 12.0 )\nv = base.dists.invgamma.entropy( 8.0, 2.0 )\n",
- "base.dists.invgamma.InvGamma": "invgamma = base.dists.invgamma.InvGamma( 6.0, 5.0 );\ninvgamma.alpha\ninvgamma.beta\ninvgamma.entropy\ninvgamma.kurtosis\ninvgamma.mean\ninvgamma.mode\ninvgamma.skewness\ninvgamma.stdev\ninvgamma.variance\ninvgamma.cdf( 0.8 )\ninvgamma.pdf( 1.0 )\ninvgamma.logpdf( 1.0 )\ninvgamma.quantile( 0.8 )\n",
- "base.dists.invgamma.kurtosis": "v = base.dists.invgamma.kurtosis( 7.0, 5.0 )\nv = base.dists.invgamma.kurtosis( 6.0, 12.0 )\nv = base.dists.invgamma.kurtosis( 8.0, 2.0 )\n",
- "base.dists.invgamma.logpdf": "y = base.dists.invgamma.logpdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.logpdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.logpdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.logpdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.logpdf( 2.0, 1.0, -1.0 )\n",
- "base.dists.invgamma.mean": "v = base.dists.invgamma.mean( 4.0, 12.0 )\nv = base.dists.invgamma.mean( 8.0, 2.0 )\n",
- "base.dists.invgamma.mode": "v = base.dists.invgamma.mode( 1.0, 1.0 )\nv = base.dists.invgamma.mode( 4.0, 12.0 )\nv = base.dists.invgamma.mode( 8.0, 2.0 )\n",
- "base.dists.invgamma.pdf": "y = base.dists.invgamma.pdf( 2.0, 0.5, 1.0 )\ny = base.dists.invgamma.pdf( 0.2, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.invgamma.pdf( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.pdf( 0.0, 1.0, NaN )\n\n// Negative shape parameter:\ny = base.dists.invgamma.pdf( 2.0, -1.0, 1.0 )\n\n// Negative scale parameter:\ny = base.dists.invgamma.pdf( 2.0, 1.0, -1.0 )\n",
- "base.dists.invgamma.quantile": "y = base.dists.invgamma.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.invgamma.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( NaN, 1.0, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, NaN, 1.0 )\ny = base.dists.invgamma.quantile( 0.0, 1.0, NaN )\n\n// Non-positive shape parameter:\ny = base.dists.invgamma.quantile( 0.5, -1.0, 1.0 )\n\n// Non-positive rate parameter:\ny = base.dists.invgamma.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.invgamma.skewness": "v = base.dists.invgamma.skewness( 4.0, 12.0 )\nv = base.dists.invgamma.skewness( 8.0, 2.0 )\n",
- "base.dists.invgamma.stdev": "v = base.dists.invgamma.stdev( 5.0, 7.0 )\nv = base.dists.invgamma.stdev( 4.0, 12.0 )\nv = base.dists.invgamma.stdev( 8.0, 2.0 )\n",
- "base.dists.invgamma.variance": "v = base.dists.invgamma.variance( 5.0, 7.0 )\nv = base.dists.invgamma.variance( 4.0, 12.0 )\nv = base.dists.invgamma.variance( 8.0, 2.0 )\n",
- "base.dists.kumaraswamy.cdf": "y = base.dists.kumaraswamy.cdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.cdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.cdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.cdf( 0.0, 1.0, NaN )\n",
- "base.dists.kumaraswamy.Kumaraswamy": "kumaraswamy = base.dists.kumaraswamy.Kumaraswamy( 6.0, 5.0 );\nkumaraswamy.a\nkumaraswamy.b\nkumaraswamy.kurtosis\nkumaraswamy.mean\nkumaraswamy.mode\nkumaraswamy.skewness\nkumaraswamy.stdev\nkumaraswamy.variance\nkumaraswamy.cdf( 0.8 )\nkumaraswamy.pdf( 1.0 )\nkumaraswamy.quantile( 0.8 )\n",
- "base.dists.kumaraswamy.kurtosis": "v = base.dists.kumaraswamy.kurtosis( 1.0, 1.0 )\nv = base.dists.kumaraswamy.kurtosis( 4.0, 12.0 )\nv = base.dists.kumaraswamy.kurtosis( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.logcdf": "y = base.dists.kumaraswamy.logcdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logcdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logcdf( 0.0, 1.0, NaN )\n",
- "base.dists.kumaraswamy.logpdf": "y = base.dists.kumaraswamy.logpdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.logpdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.logpdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.logpdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.logpdf( 0.0, 1.0, NaN )\n",
- "base.dists.kumaraswamy.mean": "v = base.dists.kumaraswamy.mean( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mean( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mean( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.median": "v = base.dists.kumaraswamy.median( 1.0, 1.0 )\nv = base.dists.kumaraswamy.median( 4.0, 12.0 )\nv = base.dists.kumaraswamy.median( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.mode": "v = base.dists.kumaraswamy.mode( 1.5, 1.5 )\nv = base.dists.kumaraswamy.mode( 4.0, 12.0 )\nv = base.dists.kumaraswamy.mode( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.pdf": "y = base.dists.kumaraswamy.pdf( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.pdf( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.pdf( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.pdf( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.pdf( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.pdf( 0.0, 1.0, NaN )\n",
- "base.dists.kumaraswamy.quantile": "y = base.dists.kumaraswamy.quantile( 0.5, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( 0.2, 2.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 0.8, 4.0, 4.0 )\ny = base.dists.kumaraswamy.quantile( -0.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 1.5, 4.0, 2.0 )\ny = base.dists.kumaraswamy.quantile( 2.0, -1.0, 0.5 )\ny = base.dists.kumaraswamy.quantile( 2.0, 0.5, -1.0 )\ny = base.dists.kumaraswamy.quantile( NaN, 1.0, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.kumaraswamy.quantile( 0.0, 1.0, NaN )\n",
- "base.dists.kumaraswamy.skewness": "v = base.dists.kumaraswamy.skewness( 1.0, 1.0 )\nv = base.dists.kumaraswamy.skewness( 4.0, 12.0 )\nv = base.dists.kumaraswamy.skewness( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.stdev": "v = base.dists.kumaraswamy.stdev( 1.0, 1.0 )\nv = base.dists.kumaraswamy.stdev( 4.0, 12.0 )\nv = base.dists.kumaraswamy.stdev( 16.0, 8.0 )\n",
- "base.dists.kumaraswamy.variance": "v = base.dists.kumaraswamy.variance( 1.0, 1.0 )\nv = base.dists.kumaraswamy.variance( 4.0, 12.0 )\nv = base.dists.kumaraswamy.variance( 16.0, 8.0 )\n",
- "base.dists.laplace.cdf": "y = base.dists.laplace.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.cdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.cdf( 2, NaN, 1.0 )\ny = base.dists.laplace.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.cdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.laplace.entropy": "y = base.dists.laplace.entropy( 0.0, 1.0 )\ny = base.dists.laplace.entropy( 4.0, 2.0 )\ny = base.dists.laplace.entropy( NaN, 1.0 )\ny = base.dists.laplace.entropy( 0.0, NaN )\ny = base.dists.laplace.entropy( 0.0, 0.0 )\n",
- "base.dists.laplace.kurtosis": "y = base.dists.laplace.kurtosis( 0.0, 1.0 )\ny = base.dists.laplace.kurtosis( 4.0, 2.0 )\ny = base.dists.laplace.kurtosis( NaN, 1.0 )\ny = base.dists.laplace.kurtosis( 0.0, NaN )\ny = base.dists.laplace.kurtosis( 0.0, 0.0 )\n",
- "base.dists.laplace.Laplace": "laplace = base.dists.laplace.Laplace( -2.0, 3.0 );\nlaplace.mu\nlaplace.b\nlaplace.entropy\nlaplace.kurtosis\nlaplace.mean\nlaplace.median\nlaplace.mode\nlaplace.skewness\nlaplace.stdev\nlaplace.variance\nlaplace.cdf( 0.8 )\nlaplace.logcdf( 0.8 )\nlaplace.logpdf( 1.0 )\nlaplace.mgf( 0.2 )\nlaplace.pdf( 2.0 )\nlaplace.quantile( 0.9 )\n",
- "base.dists.laplace.logcdf": "y = base.dists.laplace.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.laplace.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logcdf( 2, NaN, 1.0 )\ny = base.dists.laplace.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logcdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.laplace.logpdf": "y = base.dists.laplace.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.logpdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.laplace.mean": "y = base.dists.laplace.mean( 0.0, 1.0 )\ny = base.dists.laplace.mean( 4.0, 2.0 )\ny = base.dists.laplace.mean( NaN, 1.0 )\ny = base.dists.laplace.mean( 0.0, NaN )\ny = base.dists.laplace.mean( 0.0, 0.0 )\n",
- "base.dists.laplace.median": "y = base.dists.laplace.median( 0.0, 1.0 )\ny = base.dists.laplace.median( 4.0, 2.0 )\ny = base.dists.laplace.median( NaN, 1.0 )\ny = base.dists.laplace.median( 0.0, NaN )\ny = base.dists.laplace.median( 0.0, 0.0 )\n",
- "base.dists.laplace.mgf": "y = base.dists.laplace.mgf( 0.5, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.laplace.mgf( -1.0, 4.0, 0.2 )\ny = base.dists.laplace.mgf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.mgf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.mgf( 0.0, 0.0, NaN )\ny = base.dists.laplace.mgf( 1.0, 0.0, 2.0 )\ny = base.dists.laplace.mgf( -0.5, 0.0, 4.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, 0.0 )\ny = base.dists.laplace.mgf( 2.0, 0.0, -1.0 )\n",
- "base.dists.laplace.mode": "y = base.dists.laplace.mode( 0.0, 1.0 )\ny = base.dists.laplace.mode( 4.0, 2.0 )\ny = base.dists.laplace.mode( NaN, 1.0 )\ny = base.dists.laplace.mode( 0.0, NaN )\ny = base.dists.laplace.mode( 0.0, 0.0 )\n",
- "base.dists.laplace.pdf": "y = base.dists.laplace.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.laplace.pdf( -1.0, 2.0, 3.0 )\ny = base.dists.laplace.pdf( 2.5, 2.0, 3.0 )\ny = base.dists.laplace.pdf( NaN, 0.0, 1.0 )\ny = base.dists.laplace.pdf( 0.0, NaN, 1.0 )\ny = base.dists.laplace.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.pdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.laplace.quantile": "y = base.dists.laplace.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.laplace.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.laplace.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.laplace.quantile( NaN, 0.0, 1.0 )\ny = base.dists.laplace.quantile( 0.0, NaN, 1.0 )\ny = base.dists.laplace.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.laplace.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.laplace.skewness": "y = base.dists.laplace.skewness( 0.0, 1.0 )\ny = base.dists.laplace.skewness( 4.0, 2.0 )\ny = base.dists.laplace.skewness( NaN, 1.0 )\ny = base.dists.laplace.skewness( 0.0, NaN )\ny = base.dists.laplace.skewness( 0.0, 0.0 )\n",
- "base.dists.laplace.stdev": "y = base.dists.laplace.stdev( 0.0, 1.0 )\ny = base.dists.laplace.stdev( 4.0, 2.0 )\ny = base.dists.laplace.stdev( NaN, 1.0 )\ny = base.dists.laplace.stdev( 0.0, NaN )\ny = base.dists.laplace.stdev( 0.0, 0.0 )\n",
- "base.dists.laplace.variance": "y = base.dists.laplace.variance( 0.0, 1.0 )\ny = base.dists.laplace.variance( 4.0, 2.0 )\ny = base.dists.laplace.variance( NaN, 1.0 )\ny = base.dists.laplace.variance( 0.0, NaN )\ny = base.dists.laplace.variance( 0.0, 0.0 )\n",
- "base.dists.levy.cdf": "y = base.dists.levy.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.cdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.cdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.cdf( 2, NaN, 1.0 )\ny = base.dists.levy.cdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.cdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.levy.entropy": "y = base.dists.levy.entropy( 0.0, 1.0 )\ny = base.dists.levy.entropy( 4.0, 2.0 )\ny = base.dists.levy.entropy( NaN, 1.0 )\ny = base.dists.levy.entropy( 0.0, NaN )\ny = base.dists.levy.entropy( 0.0, 0.0 )\n",
- "base.dists.levy.Levy": "levy = base.dists.levy.Levy( -2.0, 3.0 );\nlevy.mu\nlevy.c\nlevy.entropy\nlevy.mean\nlevy.median\nlevy.mode\nlevy.stdev\nlevy.variance\nlevy.cdf( 0.8 )\nlevy.logcdf( 0.8 )\nlevy.logpdf( 1.0 )\nlevy.pdf( 1.0 )\nlevy.quantile( 0.8 )\n",
- "base.dists.levy.logcdf": "y = base.dists.levy.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 12.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( 9.0, 10.0, 3.0 )\ny = base.dists.levy.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logcdf( 2, NaN, 1.0 )\ny = base.dists.levy.logcdf( 2.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logcdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.levy.logpdf": "y = base.dists.levy.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.logpdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.levy.mean": "y = base.dists.levy.mean( 0.0, 1.0 )\ny = base.dists.levy.mean( 4.0, 3.0 )\ny = base.dists.levy.mean( NaN, 1.0 )\ny = base.dists.levy.mean( 0.0, NaN )\ny = base.dists.levy.mean( 0.0, 0.0 )\n",
- "base.dists.levy.median": "y = base.dists.levy.median( 0.0, 1.0 )\ny = base.dists.levy.median( 4.0, 3.0 )\ny = base.dists.levy.median( NaN, 1.0 )\ny = base.dists.levy.median( 0.0, NaN )\ny = base.dists.levy.median( 0.0, 0.0 )\n",
- "base.dists.levy.mode": "y = base.dists.levy.mode( 0.0, 1.0 )\ny = base.dists.levy.mode( 4.0, 3.0 )\ny = base.dists.levy.mode( NaN, 1.0 )\ny = base.dists.levy.mode( 0.0, NaN )\ny = base.dists.levy.mode( 0.0, 0.0 )\n",
- "base.dists.levy.pdf": "y = base.dists.levy.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.levy.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.levy.pdf( NaN, 0.0, 1.0 )\ny = base.dists.levy.pdf( 0.0, NaN, 1.0 )\ny = base.dists.levy.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.pdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.levy.quantile": "y = base.dists.levy.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.levy.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.levy.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.levy.quantile( NaN, 0.0, 1.0 )\ny = base.dists.levy.quantile( 0.0, NaN, 1.0 )\ny = base.dists.levy.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.levy.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.levy.stdev": "y = base.dists.levy.stdev( 0.0, 1.0 )\ny = base.dists.levy.stdev( 4.0, 3.0 )\ny = base.dists.levy.stdev( NaN, 1.0 )\ny = base.dists.levy.stdev( 0.0, NaN )\ny = base.dists.levy.stdev( 0.0, 0.0 )\n",
- "base.dists.levy.variance": "y = base.dists.levy.variance( 0.0, 1.0 )\ny = base.dists.levy.variance( 4.0, 3.0 )\ny = base.dists.levy.variance( NaN, 1.0 )\ny = base.dists.levy.variance( 0.0, NaN )\ny = base.dists.levy.variance( 0.0, 0.0 )\n",
- "base.dists.logistic.cdf": "y = base.dists.logistic.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.cdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.cdf( 2.0, NaN, 1.0 )\ny = base.dists.logistic.cdf( NaN, 0.0, 1.0 )\n\n// Degenerate distribution centered at `μ` when `s = 0.0`:\ny = base.dists.logistic.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.logistic.cdf( 10.0, 8.0, 0.0 )\n",
- "base.dists.logistic.entropy": "y = base.dists.logistic.entropy( 0.0, 1.0 )\ny = base.dists.logistic.entropy( 4.0, 2.0 )\ny = base.dists.logistic.entropy( NaN, 1.0 )\ny = base.dists.logistic.entropy( 0.0, NaN )\ny = base.dists.logistic.entropy( 0.0, 0.0 )\n",
- "base.dists.logistic.kurtosis": "y = base.dists.logistic.kurtosis( 0.0, 1.0 )\ny = base.dists.logistic.kurtosis( 4.0, 2.0 )\ny = base.dists.logistic.kurtosis( NaN, 1.0 )\ny = base.dists.logistic.kurtosis( 0.0, NaN )\ny = base.dists.logistic.kurtosis( 0.0, 0.0 )\n",
- "base.dists.logistic.logcdf": "y = base.dists.logistic.logcdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logcdf( 5.0, 10.0, 3.0 )\ny = base.dists.logistic.logcdf( 2.0, 0.0, NaN )\ny = base.dists.logistic.logcdf( 2, NaN, 1.0 )\ny = base.dists.logistic.logcdf( NaN, 0.0, 1.0 )\n",
- "base.dists.logistic.Logistic": "logistic = base.dists.logistic.Logistic( -2.0, 3.0 );\nlogistic.mu\nlogistic.s\nlogistic.entropy\nlogistic.kurtosis\nlogistic.mean\nlogistic.median\nlogistic.mode\nlogistic.skewness\nlogistic.stdev\nlogistic.variance\nlogistic.cdf( 0.8 )\nlogistic.logcdf( 0.8 )\nlogistic.logpdf( 2.0 )\nlogistic.mgf( 0.2 )\nlogistic.pdf( 2.0 )\nlogistic.quantile( 0.9 )\n",
- "base.dists.logistic.logpdf": "y = base.dists.logistic.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.logpdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution at `s = 0.0`:\ny = base.dists.logistic.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.logpdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.logistic.mean": "y = base.dists.logistic.mean( 0.0, 1.0 )\ny = base.dists.logistic.mean( 4.0, 2.0 )\ny = base.dists.logistic.mean( NaN, 1.0 )\ny = base.dists.logistic.mean( 0.0, NaN )\ny = base.dists.logistic.mean( 0.0, 0.0 )\n",
- "base.dists.logistic.median": "y = base.dists.logistic.median( 0.0, 1.0 )\ny = base.dists.logistic.median( 4.0, 2.0 )\ny = base.dists.logistic.median( NaN, 1.0 )\ny = base.dists.logistic.median( 0.0, NaN )\ny = base.dists.logistic.median( 0.0, 0.0 )\n",
- "base.dists.logistic.mgf": "y = base.dists.logistic.mgf( 0.9, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.1, 4.0, 4.0 )\ny = base.dists.logistic.mgf( -0.2, 4.0, 4.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, -1.0 )\ny = base.dists.logistic.mgf( 0.5, 0.0, 4.0 )\ny = base.dists.logistic.mgf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.mgf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.mgf( 0.0, 0.0, NaN )\n",
- "base.dists.logistic.mode": "y = base.dists.logistic.mode( 0.0, 1.0 )\ny = base.dists.logistic.mode( 4.0, 2.0 )\ny = base.dists.logistic.mode( NaN, 1.0 )\ny = base.dists.logistic.mode( 0.0, NaN )\ny = base.dists.logistic.mode( 0.0, 0.0 )\n",
- "base.dists.logistic.pdf": "y = base.dists.logistic.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.logistic.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.logistic.pdf( NaN, 0.0, 1.0 )\ny = base.dists.logistic.pdf( 0.0, NaN, 1.0 )\ny = base.dists.logistic.pdf( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.logistic.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.logistic.pdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.logistic.quantile": "y = base.dists.logistic.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.logistic.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.logistic.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.logistic.quantile( NaN, 0.0, 1.0 )\ny = base.dists.logistic.quantile( 0.0, NaN, 1.0 )\ny = base.dists.logistic.quantile( 0.0, 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.logistic.quantile( 0.5, 0.0, -1.0 )\n",
- "base.dists.logistic.skewness": "y = base.dists.logistic.skewness( 0.0, 1.0 )\ny = base.dists.logistic.skewness( 4.0, 2.0 )\ny = base.dists.logistic.skewness( NaN, 1.0 )\ny = base.dists.logistic.skewness( 0.0, NaN )\ny = base.dists.logistic.skewness( 0.0, 0.0 )\n",
- "base.dists.logistic.stdev": "y = base.dists.logistic.stdev( 0.0, 1.0 )\ny = base.dists.logistic.stdev( 4.0, 2.0 )\ny = base.dists.logistic.stdev( NaN, 1.0 )\ny = base.dists.logistic.stdev( 0.0, NaN )\ny = base.dists.logistic.stdev( 0.0, 0.0 )\n",
- "base.dists.logistic.variance": "y = base.dists.logistic.variance( 0.0, 1.0 )\ny = base.dists.logistic.variance( 4.0, 2.0 )\ny = base.dists.logistic.variance( NaN, 1.0 )\ny = base.dists.logistic.variance( 0.0, NaN )\ny = base.dists.logistic.variance( 0.0, 0.0 )\n",
- "base.dists.lognormal.cdf": "y = base.dists.lognormal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.cdf( 5.0, 10.0, 3.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, NaN )\ny = base.dists.lognormal.cdf( 2.0, NaN, 1.0 )\ny = base.dists.lognormal.cdf( NaN, 0.0, 1.0 )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.cdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.cdf( 2.0, 0.0, 0.0 )\n",
- "base.dists.lognormal.entropy": "y = base.dists.lognormal.entropy( 0.0, 1.0 )\ny = base.dists.lognormal.entropy( 5.0, 2.0 )\ny = base.dists.lognormal.entropy( NaN, 1.0 )\ny = base.dists.lognormal.entropy( 0.0, NaN )\ny = base.dists.lognormal.entropy( 0.0, 0.0 )\n",
- "base.dists.lognormal.kurtosis": "y = base.dists.lognormal.kurtosis( 0.0, 1.0 )\ny = base.dists.lognormal.kurtosis( 5.0, 2.0 )\ny = base.dists.lognormal.kurtosis( NaN, 1.0 )\ny = base.dists.lognormal.kurtosis( 0.0, NaN )\ny = base.dists.lognormal.kurtosis( 0.0, 0.0 )\n",
- "base.dists.lognormal.LogNormal": "lognormal = base.dists.lognormal.LogNormal( -2.0, 3.0 );\nlognormal.mu\nlognormal.sigma\nlognormal.entropy\nlognormal.kurtosis\nlognormal.mean\nlognormal.median\nlognormal.mode\nlognormal.skewness\nlognormal.stdev\nlognormal.variance\nlognormal.cdf( 0.8 )\nlognormal.logpdf( 2.0 )\nlognormal.pdf( 2.0 )\nlognormal.quantile( 0.9 )\n",
- "base.dists.lognormal.logpdf": "y = base.dists.lognormal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.logpdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.logpdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.logpdf( 2.0, 0.0, 0.0 )\n",
- "base.dists.lognormal.mean": "y = base.dists.lognormal.mean( 0.0, 1.0 )\ny = base.dists.lognormal.mean( 4.0, 2.0 )\ny = base.dists.lognormal.mean( NaN, 1.0 )\ny = base.dists.lognormal.mean( 0.0, NaN )\ny = base.dists.lognormal.mean( 0.0, 0.0 )\n",
- "base.dists.lognormal.median": "y = base.dists.lognormal.median( 0.0, 1.0 )\ny = base.dists.lognormal.median( 5.0, 2.0 )\ny = base.dists.lognormal.median( NaN, 1.0 )\ny = base.dists.lognormal.median( 0.0, NaN )\ny = base.dists.lognormal.median( 0.0, 0.0 )\n",
- "base.dists.lognormal.mode": "y = base.dists.lognormal.mode( 0.0, 1.0 )\ny = base.dists.lognormal.mode( 5.0, 2.0 )\ny = base.dists.lognormal.mode( NaN, 1.0 )\ny = base.dists.lognormal.mode( 0.0, NaN )\ny = base.dists.lognormal.mode( 0.0, 0.0 )\n",
- "base.dists.lognormal.pdf": "y = base.dists.lognormal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 1.0, 3.0, 1.0 )\ny = base.dists.lognormal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.lognormal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.pdf( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.pdf( 2.0, 0.0, -1.0 )\ny = base.dists.lognormal.pdf( 2.0, 0.0, 0.0 )\n",
- "base.dists.lognormal.quantile": "y = base.dists.lognormal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.lognormal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.lognormal.quantile( 0.0, 0.0, NaN )\n\n// Non-positive scale parameter `σ`:\ny = base.dists.lognormal.quantile( 0.5, 0.0, -1.0 )\ny = base.dists.lognormal.quantile( 0.5, 0.0, 0.0 )\n",
- "base.dists.lognormal.skewness": "y = base.dists.lognormal.skewness( 0.0, 1.0 )\ny = base.dists.lognormal.skewness( 5.0, 2.0 )\ny = base.dists.lognormal.skewness( NaN, 1.0 )\ny = base.dists.lognormal.skewness( 0.0, NaN )\ny = base.dists.lognormal.skewness( 0.0, 0.0 )\n",
- "base.dists.lognormal.stdev": "y = base.dists.lognormal.stdev( 0.0, 1.0 )\ny = base.dists.lognormal.stdev( 4.0, 2.0 )\ny = base.dists.lognormal.stdev( NaN, 1.0 )\ny = base.dists.lognormal.stdev( 0.0, NaN )\ny = base.dists.lognormal.stdev( 0.0, 0.0 )\n",
- "base.dists.lognormal.variance": "y = base.dists.lognormal.variance( 0.0, 1.0 )\ny = base.dists.lognormal.variance( 4.0, 2.0 )\ny = base.dists.lognormal.variance( NaN, 1.0 )\ny = base.dists.lognormal.variance( 0.0, NaN )\ny = base.dists.lognormal.variance( 0.0, 0.0 )\n",
- "base.dists.negativeBinomial.cdf": "y = base.dists.negativeBinomial.cdf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.cdf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.cdf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.cdf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.cdf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.cdf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.cdf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.cdf( 2.0, 20, 1.5 )\n",
- "base.dists.negativeBinomial.kurtosis": "v = base.dists.negativeBinomial.kurtosis( 100, 0.2 )\nv = base.dists.negativeBinomial.kurtosis( 20, 0.5 )\n",
- "base.dists.negativeBinomial.logpmf": "y = base.dists.negativeBinomial.logpmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.logpmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.logpmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.logpmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.logpmf( 0.0, 20.0, NaN )\n",
- "base.dists.negativeBinomial.mean": "v = base.dists.negativeBinomial.mean( 100, 0.2 )\nv = base.dists.negativeBinomial.mean( 20, 0.5 )\n",
- "base.dists.negativeBinomial.mgf": "y = base.dists.negativeBinomial.mgf( 0.05, 20.0, 0.8 )\ny = base.dists.negativeBinomial.mgf( 0.1, 20.0, 0.1 )\ny = base.dists.negativeBinomial.mgf( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.mgf( 0.1, 0.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.1, -2.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.mgf( 0.0, 20.0, NaN )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, -1.0 )\ny = base.dists.negativeBinomial.mgf( 0.2, 20, 1.5 )\n",
- "base.dists.negativeBinomial.mode": "v = base.dists.negativeBinomial.mode( 100, 0.2 )\nv = base.dists.negativeBinomial.mode( 20, 0.5 )\n",
- "base.dists.negativeBinomial.NegativeBinomial": "nbinomial = base.dists.negativeBinomial.NegativeBinomial( 8.0, 0.5 );\nnbinomial.r\nnbinomial.p\nnbinomial.kurtosis\nnbinomial.mean\nnbinomial.mode\nnbinomial.skewness\nnbinomial.stdev\nnbinomial.variance\nnbinomial.cdf( 2.9 )\nnbinomial.logpmf( 3.0 )\nnbinomial.mgf( 0.2 )\nnbinomial.pmf( 3.0 )\nnbinomial.quantile( 0.8 )\n",
- "base.dists.negativeBinomial.pmf": "y = base.dists.negativeBinomial.pmf( 5.0, 20.0, 0.8 )\ny = base.dists.negativeBinomial.pmf( 21.0, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 10.0, 0.4 )\ny = base.dists.negativeBinomial.pmf( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.pmf( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.pmf( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.pmf( 2.0, 0.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, -2.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, -1.0 )\ny = base.dists.negativeBinomial.pmf( 2.0, 20, 1.5 )\ny = base.dists.negativeBinomial.pmf( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, NaN, 0.5 )\ny = base.dists.negativeBinomial.pmf( 0.0, 20.0, NaN )\n",
- "base.dists.negativeBinomial.quantile": "y = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.2 )\ny = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.8 )\ny = base.dists.negativeBinomial.quantile( 0.5, 10.0, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.0, 10.0, 0.9 )\ny = base.dists.negativeBinomial.quantile( 1.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( -0.1, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 21.0, 15.5, 0.5 )\ny = base.dists.negativeBinomial.quantile( 5.0, 7.4, 0.4 )\ny = base.dists.negativeBinomial.quantile( 0.5, 0.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.5, -2.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, -1.0 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, 1.5 )\ny = base.dists.negativeBinomial.quantile( NaN, 20.0, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, NaN, 0.5 )\ny = base.dists.negativeBinomial.quantile( 0.3, 20.0, NaN )\n",
- "base.dists.negativeBinomial.skewness": "v = base.dists.negativeBinomial.skewness( 100, 0.2 )\nv = base.dists.negativeBinomial.skewness( 20, 0.5 )\n",
- "base.dists.negativeBinomial.stdev": "v = base.dists.negativeBinomial.stdev( 100, 0.2 )\nv = base.dists.negativeBinomial.stdev( 20, 0.5 )\n",
- "base.dists.negativeBinomial.variance": "v = base.dists.negativeBinomial.variance( 100, 0.2 )\nv = base.dists.negativeBinomial.variance( 20, 0.5 )\n",
- "base.dists.normal.cdf": "y = base.dists.normal.cdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.cdf( -1.0, -1.0, 2.0 )\ny = base.dists.normal.cdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.cdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.cdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.cdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.cdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.cdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 8.0, 8.0, 0.0 )\ny = base.dists.normal.cdf( 10.0, 8.0, 0.0 )\n",
- "base.dists.normal.entropy": "y = base.dists.normal.entropy( 0.0, 1.0 )\ny = base.dists.normal.entropy( 4.0, 3.0 )\ny = base.dists.normal.entropy( NaN, 1.0 )\ny = base.dists.normal.entropy( 0.0, NaN )\ny = base.dists.normal.entropy( 0.0, 0.0 )\n",
- "base.dists.normal.kurtosis": "y = base.dists.normal.kurtosis( 0.0, 1.0 )\ny = base.dists.normal.kurtosis( 4.0, 3.0 )\ny = base.dists.normal.kurtosis( NaN, 1.0 )\ny = base.dists.normal.kurtosis( 0.0, NaN )\ny = base.dists.normal.kurtosis( 0.0, 0.0 )\n",
- "base.dists.normal.logpdf": "y = base.dists.normal.logpdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.logpdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.logpdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.logpdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.logpdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.normal.mean": "y = base.dists.normal.mean( 0.0, 1.0 )\ny = base.dists.normal.mean( 4.0, 2.0 )\ny = base.dists.normal.mean( NaN, 1.0 )\ny = base.dists.normal.mean( 0.0, NaN )\ny = base.dists.normal.mean( 0.0, 0.0 )\n",
- "base.dists.normal.median": "y = base.dists.normal.median( 0.0, 1.0 )\ny = base.dists.normal.median( 4.0, 2.0 )\ny = base.dists.normal.median( NaN, 1.0 )\ny = base.dists.normal.median( 0.0, NaN )\ny = base.dists.normal.median( 0.0, 0.0 )\n",
- "base.dists.normal.mgf": "y = base.dists.normal.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, 1.0 )\ny = base.dists.normal.mgf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.mgf( NaN, 0.0, 1.0 )\ny = base.dists.normal.mgf( 0.0, NaN, 1.0 )\ny = base.dists.normal.mgf( 0.0, 0.0, NaN )\ny = base.dists.normal.mgf( 2.0, 0.0, 0.0 )\n",
- "base.dists.normal.mode": "y = base.dists.normal.mode( 0.0, 1.0 )\ny = base.dists.normal.mode( 4.0, 2.0 )\ny = base.dists.normal.mode( NaN, 1.0 )\ny = base.dists.normal.mode( 0.0, NaN )\ny = base.dists.normal.mode( 0.0, 0.0 )\n",
- "base.dists.normal.Normal": "normal = base.dists.normal.Normal( -2.0, 3.0 );\nnormal.mu\nnormal.sigma\nnormal.entropy\nnormal.kurtosis\nnormal.mean\nnormal.median\nnormal.mode\nnormal.skewness\nnormal.stdev\nnormal.variance\nnormal.cdf( 0.8 )\nnormal.logpdf( 2.0 )\nnormal.mgf( 0.2 )\nnormal.pdf( 2.0 )\nnormal.quantile( 0.9 )\n",
- "base.dists.normal.pdf": "y = base.dists.normal.pdf( 2.0, 0.0, 1.0 )\ny = base.dists.normal.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.normal.pdf( NaN, 0.0, 1.0 )\ny = base.dists.normal.pdf( 0.0, NaN, 1.0 )\ny = base.dists.normal.pdf( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.pdf( 2.0, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.pdf( 2.0, 8.0, 0.0 )\ny = base.dists.normal.pdf( 8.0, 8.0, 0.0 )\n",
- "base.dists.normal.quantile": "y = base.dists.normal.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.5, 4.0, 2.0 )\ny = base.dists.normal.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.normal.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.normal.quantile( NaN, 0.0, 1.0 )\ny = base.dists.normal.quantile( 0.0, NaN, 1.0 )\ny = base.dists.normal.quantile( 0.0, 0.0, NaN )\n\n// Negative standard deviation:\ny = base.dists.normal.quantile( 0.5, 0.0, -1.0 )\n\n// Degenerate distribution centered at `μ` when `σ = 0.0`:\ny = base.dists.normal.quantile( 0.3, 8.0, 0.0 )\ny = base.dists.normal.quantile( 0.9, 8.0, 0.0 )\n",
- "base.dists.normal.skewness": "y = base.dists.normal.skewness( 0.0, 1.0 )\ny = base.dists.normal.skewness( 4.0, 3.0 )\ny = base.dists.normal.skewness( NaN, 1.0 )\ny = base.dists.normal.skewness( 0.0, NaN )\ny = base.dists.normal.skewness( 0.0, 0.0 )\n",
- "base.dists.normal.stdev": "y = base.dists.normal.stdev( 0.0, 1.0 )\ny = base.dists.normal.stdev( 4.0, 3.0 )\ny = base.dists.normal.stdev( NaN, 1.0 )\ny = base.dists.normal.stdev( 0.0, NaN )\ny = base.dists.normal.stdev( 0.0, 0.0 )\n",
- "base.dists.normal.variance": "y = base.dists.normal.variance( 0.0, 1.0 )\ny = base.dists.normal.variance( 4.0, 3.0 )\ny = base.dists.normal.variance( NaN, 1.0 )\ny = base.dists.normal.variance( 0.0, NaN )\ny = base.dists.normal.variance( 0.0, 0.0 )\n",
- "base.dists.pareto1.cdf": "y = base.dists.pareto1.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.cdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.cdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.cdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.cdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.cdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.cdf( 0.0, 1.0, NaN )\n",
- "base.dists.pareto1.entropy": "v = base.dists.pareto1.entropy( 0.8, 1.0 )\nv = base.dists.pareto1.entropy( 4.0, 12.0 )\nv = base.dists.pareto1.entropy( 8.0, 2.0 )\n",
- "base.dists.pareto1.kurtosis": "v = base.dists.pareto1.kurtosis( 5.0, 1.0 )\nv = base.dists.pareto1.kurtosis( 4.5, 12.0 )\nv = base.dists.pareto1.kurtosis( 8.0, 2.0 )\n",
- "base.dists.pareto1.logcdf": "y = base.dists.pareto1.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 5.0, 2.0, 4.0 )\ny = base.dists.pareto1.logcdf( 4.0, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( 1.9, 2.0, 2.0 )\ny = base.dists.pareto1.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.pareto1.logcdf( 2.0, -1.0, 0.5 )\ny = base.dists.pareto1.logcdf( 2.0, 0.5, -1.0 )\ny = base.dists.pareto1.logcdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.pareto1.logcdf( 0.0, 1.0, NaN )\n",
- "base.dists.pareto1.logpdf": "y = base.dists.pareto1.logpdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.logpdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.logpdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.logpdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.logpdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.logpdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.logpdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.logpdf( 0.5, 1.0, NaN )\n",
- "base.dists.pareto1.mean": "v = base.dists.pareto1.mean( 0.8, 1.0 )\nv = base.dists.pareto1.mean( 4.0, 12.0 )\nv = base.dists.pareto1.mean( 8.0, 2.0 )\n",
- "base.dists.pareto1.median": "v = base.dists.pareto1.median( 0.8, 1.0 )\nv = base.dists.pareto1.median( 4.0, 12.0 )\nv = base.dists.pareto1.median( 8.0, 2.0 )\n",
- "base.dists.pareto1.mode": "v = base.dists.pareto1.mode( 0.8, 1.0 )\nv = base.dists.pareto1.mode( 4.0, 12.0 )\nv = base.dists.pareto1.mode( 8.0, 2.0 )\n",
- "base.dists.pareto1.Pareto1": "pareto1 = base.dists.pareto1.Pareto1( 6.0, 5.0 );\npareto1.alpha\npareto1.beta\npareto1.entropy\npareto1.kurtosis\npareto1.mean\npareto1.median\npareto1.mode\npareto1.skewness\npareto1.variance\npareto1.cdf( 7.0 )\npareto1.logcdf( 7.0 )\npareto1.logpdf( 5.0 )\npareto1.pdf( 5.0 )\npareto1.quantile( 0.8 )\n",
- "base.dists.pareto1.pdf": "y = base.dists.pareto1.pdf( 4.0, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 20.0, 1.0, 10.0 )\ny = base.dists.pareto1.pdf( 7.0, 2.0, 6.0 )\ny = base.dists.pareto1.pdf( 7.0, 6.0, 3.0 )\ny = base.dists.pareto1.pdf( 1.0, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 1.5, 4.0, 2.0 )\ny = base.dists.pareto1.pdf( 0.5, -1.0, 0.5 )\ny = base.dists.pareto1.pdf( 0.5, 0.5, -1.0 )\ny = base.dists.pareto1.pdf( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.pdf( 0.5, 1.0, NaN )\n",
- "base.dists.pareto1.quantile": "y = base.dists.pareto1.quantile( 0.8, 2.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.8, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 0.1, 1.0, 10.0 )\ny = base.dists.pareto1.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( NaN, 1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, NaN, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, NaN )\ny = base.dists.pareto1.quantile( 0.5, -1.0, 1.0 )\ny = base.dists.pareto1.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.pareto1.skewness": "v = base.dists.pareto1.skewness( 3.5, 1.0 )\nv = base.dists.pareto1.skewness( 4.0, 12.0 )\nv = base.dists.pareto1.skewness( 8.0, 2.0 )\n",
- "base.dists.pareto1.variance": "v = base.dists.pareto1.variance( 0.8, 1.0 )\nv = base.dists.pareto1.variance( 4.0, 12.0 )\nv = base.dists.pareto1.variance( 8.0, 2.0 )\n",
- "base.dists.poisson.cdf": "y = base.dists.poisson.cdf( 2.0, 0.5 )\ny = base.dists.poisson.cdf( 2.0, 10.0 )\ny = base.dists.poisson.cdf( -1.0, 4.0 )\ny = base.dists.poisson.cdf( NaN, 1.0 )\ny = base.dists.poisson.cdf( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.cdf( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.cdf( -2.0, 0.0 )\ny = base.dists.poisson.cdf( 0.0, 0.0 )\ny = base.dists.poisson.cdf( 10.0, 0.0 )\n",
- "base.dists.poisson.entropy": "v = base.dists.poisson.entropy( 11.0 )\nv = base.dists.poisson.entropy( 4.5 )\n",
- "base.dists.poisson.kurtosis": "v = base.dists.poisson.kurtosis( 11.0 )\nv = base.dists.poisson.kurtosis( 4.5 )\n",
- "base.dists.poisson.logpmf": "y = base.dists.poisson.logpmf( 4.0, 3.0 )\ny = base.dists.poisson.logpmf( 1.0, 3.0 )\ny = base.dists.poisson.logpmf( -1.0, 2.0 )\ny = base.dists.poisson.logpmf( 0.0, NaN )\ny = base.dists.poisson.logpmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.logpmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.logpmf( 2.0, 0.0 )\ny = base.dists.poisson.logpmf( 0.0, 0.0 )\n",
- "base.dists.poisson.mean": "v = base.dists.poisson.mean( 11.0 )\nv = base.dists.poisson.mean( 4.5 )\n",
- "base.dists.poisson.median": "v = base.dists.poisson.median( 11.0 )\nv = base.dists.poisson.median( 4.5 )\n",
- "base.dists.poisson.mode": "v = base.dists.poisson.mode( 11.0 )\nv = base.dists.poisson.mode( 4.5 )\n",
- "base.dists.poisson.pmf": "y = base.dists.poisson.pmf( 4.0, 3.0 )\ny = base.dists.poisson.pmf( 1.0, 3.0 )\ny = base.dists.poisson.pmf( -1.0, 2.0 )\ny = base.dists.poisson.pmf( 0.0, NaN )\ny = base.dists.poisson.pmf( NaN, 0.5 )\n\n// Negative mean parameter:\ny = base.dists.poisson.pmf( 2.0, -0.5 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.pmf( 2.0, 0.0 )\ny = base.dists.poisson.pmf( 0.0, 0.0 )\n",
- "base.dists.poisson.Poisson": "poisson = base.dists.poisson.Poisson( 6.0 );\npoisson.lambda\npoisson.entropy\npoisson.kurtosis\npoisson.mean\npoisson.median\npoisson.mode\npoisson.skewness\npoisson.stdev\npoisson.variance\npoisson.cdf( 4.0 )\npoisson.logpmf( 2.0 )\npoisson.mgf( 0.5 )\npoisson.pmf( 2.0 )\npoisson.quantile( 0.5 )\n",
- "base.dists.poisson.quantile": "y = base.dists.poisson.quantile( 0.5, 2.0 )\ny = base.dists.poisson.quantile( 0.9, 4.0 )\ny = base.dists.poisson.quantile( 0.1, 200.0 )\ny = base.dists.poisson.quantile( 1.1, 0.0 )\ny = base.dists.poisson.quantile( -0.2, 0.0 )\ny = base.dists.poisson.quantile( NaN, 0.5 )\ny = base.dists.poisson.quantile( 0.0, NaN )\n\n// Negative mean parameter:\ny = base.dists.poisson.quantile( 2.0, -1.0 )\n\n// Degenerate distribution at `λ = 0`:\ny = base.dists.poisson.quantile( 0.1, 0.0 )\ny = base.dists.poisson.quantile( 0.9, 0.0 )\n",
- "base.dists.poisson.skewness": "v = base.dists.poisson.skewness( 11.0 )\nv = base.dists.poisson.skewness( 4.5 )\n",
- "base.dists.poisson.stdev": "v = base.dists.poisson.stdev( 11.0 )\nv = base.dists.poisson.stdev( 4.5 )\n",
- "base.dists.poisson.variance": "v = base.dists.poisson.variance( 11.0 )\nv = base.dists.poisson.variance( 4.5 )\n",
- "base.dists.rayleigh.cdf": "y = base.dists.rayleigh.cdf( 2.0, 3.0 )\ny = base.dists.rayleigh.cdf( 1.0, 2.0 )\ny = base.dists.rayleigh.cdf( -1.0, 4.0 )\ny = base.dists.rayleigh.cdf( NaN, 1.0 )\ny = base.dists.rayleigh.cdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.cdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.cdf( -2.0, 0.0 )\ny = base.dists.rayleigh.cdf( 0.0, 0.0 )\ny = base.dists.rayleigh.cdf( 2.0, 0.0 )\n",
- "base.dists.rayleigh.entropy": "v = base.dists.rayleigh.entropy( 11.0 )\nv = base.dists.rayleigh.entropy( 4.5 )\n",
- "base.dists.rayleigh.kurtosis": "v = base.dists.rayleigh.kurtosis( 11.0 )\nv = base.dists.rayleigh.kurtosis( 4.5 )\n",
- "base.dists.rayleigh.logcdf": "y = base.dists.rayleigh.logcdf( 2.0, 3.0 )\ny = base.dists.rayleigh.logcdf( 1.0, 2.0 )\ny = base.dists.rayleigh.logcdf( -1.0, 4.0 )\ny = base.dists.rayleigh.logcdf( NaN, 1.0 )\ny = base.dists.rayleigh.logcdf( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logcdf( 2.0, -1.0 )\n",
- "base.dists.rayleigh.logpdf": "y = base.dists.rayleigh.logpdf( 0.3, 1.0 )\ny = base.dists.rayleigh.logpdf( 2.0, 0.8 )\ny = base.dists.rayleigh.logpdf( -1.0, 0.5 )\ny = base.dists.rayleigh.logpdf( 0.0, NaN )\ny = base.dists.rayleigh.logpdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.logpdf( 2.0, -1.0 )\n",
- "base.dists.rayleigh.mean": "v = base.dists.rayleigh.mean( 11.0 )\nv = base.dists.rayleigh.mean( 4.5 )\n",
- "base.dists.rayleigh.median": "v = base.dists.rayleigh.median( 11.0 )\nv = base.dists.rayleigh.median( 4.5 )\n",
- "base.dists.rayleigh.mgf": "y = base.dists.rayleigh.mgf( 1.0, 3.0 )\ny = base.dists.rayleigh.mgf( 1.0, 2.0 )\ny = base.dists.rayleigh.mgf( -1.0, 4.0 )\ny = base.dists.rayleigh.mgf( NaN, 1.0 )\ny = base.dists.rayleigh.mgf( 0.0, NaN )\ny = base.dists.rayleigh.mgf( 0.5, -1.0 )\n",
- "base.dists.rayleigh.mode": "v = base.dists.rayleigh.mode( 11.0 )\nv = base.dists.rayleigh.mode( 4.5 )\n",
- "base.dists.rayleigh.pdf": "y = base.dists.rayleigh.pdf( 0.3, 1.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.8 )\ny = base.dists.rayleigh.pdf( -1.0, 0.5 )\ny = base.dists.rayleigh.pdf( 0.0, NaN )\ny = base.dists.rayleigh.pdf( NaN, 2.0 )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.pdf( 2.0, -1.0 )\n\n// Degenerate distribution when `sigma = 0.0`:\ny = base.dists.rayleigh.pdf( -2.0, 0.0 )\ny = base.dists.rayleigh.pdf( 0.0, 0.0 )\ny = base.dists.rayleigh.pdf( 2.0, 0.0 )\n",
- "base.dists.rayleigh.quantile": "y = base.dists.rayleigh.quantile( 0.8, 1.0 )\ny = base.dists.rayleigh.quantile( 0.5, 4.0 )\ny = base.dists.rayleigh.quantile( 1.1, 1.0 )\ny = base.dists.rayleigh.quantile( -0.2, 1.0 )\ny = base.dists.rayleigh.quantile( NaN, 1.0 )\ny = base.dists.rayleigh.quantile( 0.0, NaN )\n\n// Negative scale parameter:\ny = base.dists.rayleigh.quantile( 0.5, -1.0 )\n",
- "base.dists.rayleigh.Rayleigh": "rayleigh = base.dists.rayleigh.Rayleigh( 6.0 );\nrayleigh.sigma\nrayleigh.entropy\nrayleigh.kurtosis\nrayleigh.mean\nrayleigh.median\nrayleigh.mode\nrayleigh.skewness\nrayleigh.stdev\nrayleigh.variance\nrayleigh.cdf( 1.0 )\nrayleigh.logcdf( 1.0 )\nrayleigh.logpdf( 1.5 )\nrayleigh.mgf( -0.5 )\nrayleigh.pdf( 1.5 )\nrayleigh.quantile( 0.5 )\n",
- "base.dists.rayleigh.skewness": "v = base.dists.rayleigh.skewness( 11.0 )\nv = base.dists.rayleigh.skewness( 4.5 )\n",
- "base.dists.rayleigh.stdev": "v = base.dists.rayleigh.stdev( 9.0 )\nv = base.dists.rayleigh.stdev( 4.5 )\n",
- "base.dists.rayleigh.variance": "v = base.dists.rayleigh.variance( 9.0 )\nv = base.dists.rayleigh.variance( 4.5 )\n",
- "base.dists.t.cdf": "y = base.dists.t.cdf( 2.0, 0.1 )\ny = base.dists.t.cdf( 1.0, 2.0 )\ny = base.dists.t.cdf( -1.0, 4.0 )\ny = base.dists.t.cdf( NaN, 1.0 )\ny = base.dists.t.cdf( 0.0, NaN )\ny = base.dists.t.cdf( 2.0, -1.0 )\n",
- "base.dists.t.entropy": "v = base.dists.t.entropy( 11.0 )\nv = base.dists.t.entropy( 4.5 )\n",
- "base.dists.t.kurtosis": "v = base.dists.t.kurtosis( 11.0 )\nv = base.dists.t.kurtosis( 4.5 )\n",
- "base.dists.t.mean": "v = base.dists.t.mean( 11.0 )\nv = base.dists.t.mean( 4.5 )\n",
- "base.dists.t.median": "v = base.dists.t.median( 11.0 )\nv = base.dists.t.median( 4.5 )\n",
- "base.dists.t.mode": "v = base.dists.t.mode( 11.0 )\nv = base.dists.t.mode( 4.5 )\n",
- "base.dists.t.pdf": "y = base.dists.t.pdf( 0.3, 4.0 )\ny = base.dists.t.pdf( 2.0, 0.7 )\ny = base.dists.t.pdf( -1.0, 0.5 )\ny = base.dists.t.pdf( 0.0, NaN )\ny = base.dists.t.pdf( NaN, 2.0 )\ny = base.dists.t.pdf( 2.0, -1.0 )\n",
- "base.dists.t.quantile": "y = base.dists.t.quantile( 0.8, 1.0 )\ny = base.dists.t.quantile( 0.1, 1.0 )\ny = base.dists.t.quantile( 0.5, 0.1 )\ny = base.dists.t.quantile( -0.2, 0.1 )\ny = base.dists.t.quantile( NaN, 1.0 )\ny = base.dists.t.quantile( 0.0, NaN )\ny = base.dists.t.quantile( 0.5, -1.0 )\n",
- "base.dists.t.skewness": "v = base.dists.t.skewness( 11.0 )\nv = base.dists.t.skewness( 4.5 )\n",
- "base.dists.t.stdev": "v = base.dists.t.stdev( 9.0 )\nv = base.dists.t.stdev( 4.5 )\n",
- "base.dists.t.T": "t = base.dists.t.T( 6.0 );\nt.v\nt.entropy\nt.kurtosis\nt.mean\nt.median\nt.mode\nt.skewness\nt.stdev\nt.variance\nt.cdf( 1.0 )\nt.logcdf( 1.0 )\nt.logpdf( 1.5 )\nt.pdf( 1.5 )\nt.quantile( 0.8 )\n",
- "base.dists.t.variance": "v = base.dists.t.variance( 9.0 )\nv = base.dists.t.variance( 4.5 )\n",
- "base.dists.triangular.cdf": "y = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.cdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.cdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.cdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.cdf( 2.0, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.entropy": "v = base.dists.triangular.entropy( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.entropy( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.entropy( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.kurtosis": "v = base.dists.triangular.kurtosis( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.kurtosis( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.kurtosis( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.logcdf": "y = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logcdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logcdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logcdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.logpdf": "y = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.logpdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.logpdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.logpdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.mean": "v = base.dists.triangular.mean( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mean( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mean( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.median": "v = base.dists.triangular.median( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.median( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.median( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.mgf": "y = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( -0.3, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.mgf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.mgf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.mgf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, NaN )\ny = base.dists.triangular.mgf( 0.5, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.mode": "v = base.dists.triangular.mode( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.mode( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.mode( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.pdf": "y = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( -10.0, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.pdf( -2.0, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.pdf( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, NaN, 1.0, 0.5 )\ny = base.dists.triangular.pdf( 0.0, 0.0, NaN, 0.5 )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, NaN )\ny = base.dists.triangular.pdf( 2.0, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.quantile": "y = base.dists.triangular.quantile( 0.9, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( 0.1, -1.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.1, -20.0, 0.0, -2.0 )\ny = base.dists.triangular.quantile( 0.8, 0.0, 20.0, 0.0 )\ny = base.dists.triangular.quantile( 1.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( -0.1, -1.0, 1.0, 0.0 )\ny = base.dists.triangular.quantile( NaN, 0.0, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, NaN, 1.0, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 0.0, NaN, 0.5 )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, NaN )\ny = base.dists.triangular.quantile( 0.3, 1.0, 0.0, 1.5 )\n",
- "base.dists.triangular.skewness": "v = base.dists.triangular.skewness( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.skewness( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.skewness( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.stdev": "v = base.dists.triangular.stdev( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.stdev( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.stdev( 2.0, 8.0, 5.0 )\n",
- "base.dists.triangular.Triangular": "triangular = base.dists.triangular.Triangular( 0.0, 1.0, 0.5 );\ntriangular.a\ntriangular.b\ntriangular.c\ntriangular.entropy\ntriangular.kurtosis\ntriangular.mean\ntriangular.median\ntriangular.mode\ntriangular.skewness\ntriangular.stdev\ntriangular.variance\ntriangular.cdf( 0.8 )\ntriangular.logcdf( 0.8 )\ntriangular.logpdf( 0.8 )\ntriangular.mgf( 0.8 )\ntriangular.pdf( 0.8 )\ntriangular.quantile( 0.8 )\n",
- "base.dists.triangular.variance": "v = base.dists.triangular.variance( 0.0, 1.0, 0.8 )\nv = base.dists.triangular.variance( 4.0, 12.0, 5.0 )\nv = base.dists.triangular.variance( 2.0, 8.0, 5.0 )\n",
- "base.dists.uniform.cdf": "y = base.dists.uniform.cdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.cdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.cdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.cdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.cdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.cdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.cdf( 2.0, 1.0, 0.0 )\n",
- "base.dists.uniform.entropy": "v = base.dists.uniform.entropy( 0.0, 1.0 )\nv = base.dists.uniform.entropy( 4.0, 12.0 )\nv = base.dists.uniform.entropy( 2.0, 8.0 )\n",
- "base.dists.uniform.kurtosis": "v = base.dists.uniform.kurtosis( 0.0, 1.0 )\nv = base.dists.uniform.kurtosis( 4.0, 12.0 )\nv = base.dists.uniform.kurtosis( 2.0, 8.0 )\n",
- "base.dists.uniform.logcdf": "y = base.dists.uniform.logcdf( 9.0, 0.0, 10.0 )\ny = base.dists.uniform.logcdf( 0.5, 0.0, 2.0 )\ny = base.dists.uniform.logcdf( PINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NINF, 2.0, 4.0 )\ny = base.dists.uniform.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logcdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logcdf( 2.0, 1.0, 0.0 )\n",
- "base.dists.uniform.logpdf": "y = base.dists.uniform.logpdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.logpdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.logpdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.logpdf( 2.0, 3.0, 1.0 )\n",
- "base.dists.uniform.mean": "v = base.dists.uniform.mean( 0.0, 1.0 )\nv = base.dists.uniform.mean( 4.0, 12.0 )\nv = base.dists.uniform.mean( 2.0, 8.0 )\n",
- "base.dists.uniform.median": "v = base.dists.uniform.median( 0.0, 1.0 )\nv = base.dists.uniform.median( 4.0, 12.0 )\nv = base.dists.uniform.median( 2.0, 8.0 )\n",
- "base.dists.uniform.mgf": "y = base.dists.uniform.mgf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.mgf( -0.2, 0.0, 4.0 )\ny = base.dists.uniform.mgf( 2.0, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 2.0 )\ny = base.dists.uniform.mgf( 0.5, 3.0, 3.0 )\ny = base.dists.uniform.mgf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.mgf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.mgf( 0.0, 0.0, NaN )\n",
- "base.dists.uniform.pdf": "y = base.dists.uniform.pdf( 2.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 5.0, 0.0, 4.0 )\ny = base.dists.uniform.pdf( 0.25, 0.0, 1.0 )\ny = base.dists.uniform.pdf( NaN, 0.0, 1.0 )\ny = base.dists.uniform.pdf( 0.0, NaN, 1.0 )\ny = base.dists.uniform.pdf( 0.0, 0.0, NaN )\ny = base.dists.uniform.pdf( 2.0, 3.0, 1.0 )\n",
- "base.dists.uniform.quantile": "y = base.dists.uniform.quantile( 0.8, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.5, 0.0, 10.0 )\ny = base.dists.uniform.quantile( 1.1, 0.0, 1.0 )\ny = base.dists.uniform.quantile( -0.2, 0.0, 1.0 )\ny = base.dists.uniform.quantile( NaN, 0.0, 1.0 )\ny = base.dists.uniform.quantile( 0.0, NaN, 1.0 )\ny = base.dists.uniform.quantile( 0.0, 0.0, NaN )\ny = base.dists.uniform.quantile( 0.5, 2.0, 1.0 )\n",
- "base.dists.uniform.skewness": "v = base.dists.uniform.skewness( 0.0, 1.0 )\nv = base.dists.uniform.skewness( 4.0, 12.0 )\nv = base.dists.uniform.skewness( 2.0, 8.0 )\n",
- "base.dists.uniform.stdev": "v = base.dists.uniform.stdev( 0.0, 1.0 )\nv = base.dists.uniform.stdev( 4.0, 12.0 )\nv = base.dists.uniform.stdev( 2.0, 8.0 )\n",
- "base.dists.uniform.Uniform": "uniform = base.dists.uniform.Uniform( 0.0, 1.0 );\nuniform.a\nuniform.b\nuniform.entropy\nuniform.kurtosis\nuniform.mean\nuniform.median\nuniform.skewness\nuniform.stdev\nuniform.variance\nuniform.cdf( 0.8 )\nuniform.logcdf( 0.5 )\nuniform.logpdf( 1.0 )\nuniform.mgf( 0.8 )\nuniform.pdf( 0.8 )\nuniform.quantile( 0.8 )\n",
- "base.dists.uniform.variance": "v = base.dists.uniform.variance( 0.0, 1.0 )\nv = base.dists.uniform.variance( 4.0, 12.0 )\nv = base.dists.uniform.variance( 2.0, 8.0 )\n",
- "base.dists.weibull.cdf": "y = base.dists.weibull.cdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.cdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.cdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.cdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.cdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.cdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.cdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.weibull.entropy": "v = base.dists.weibull.entropy( 1.0, 1.0 )\nv = base.dists.weibull.entropy( 4.0, 12.0 )\nv = base.dists.weibull.entropy( 8.0, 2.0 )\n",
- "base.dists.weibull.kurtosis": "v = base.dists.weibull.kurtosis( 1.0, 1.0 )\nv = base.dists.weibull.kurtosis( 4.0, 12.0 )\nv = base.dists.weibull.kurtosis( 8.0, 2.0 )\n",
- "base.dists.weibull.logcdf": "y = base.dists.weibull.logcdf( 2.0, 1.0, 1.0 )\ny = base.dists.weibull.logcdf( -1.0, 2.0, 2.0 )\ny = base.dists.weibull.logcdf( PINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NINF, 4.0, 2.0 )\ny = base.dists.weibull.logcdf( NaN, 0.0, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logcdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logcdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.weibull.logpdf": "y = base.dists.weibull.logpdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.logpdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.logpdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.logpdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.logpdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.logpdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.weibull.mean": "v = base.dists.weibull.mean( 1.0, 1.0 )\nv = base.dists.weibull.mean( 4.0, 12.0 )\nv = base.dists.weibull.mean( 8.0, 2.0 )\n",
- "base.dists.weibull.median": "v = base.dists.weibull.median( 1.0, 1.0 )\nv = base.dists.weibull.median( 4.0, 12.0 )\nv = base.dists.weibull.median( 8.0, 2.0 )\n",
- "base.dists.weibull.mgf": "y = base.dists.weibull.mgf( 1.0, 1.0, 0.5 )\ny = base.dists.weibull.mgf( -1.0, 4.0, 4.0 )\ny = base.dists.weibull.mgf( NaN, 1.0, 1.0 )\ny = base.dists.weibull.mgf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.mgf( 0.0, 1.0, NaN )\ny = base.dists.weibull.mgf( 0.2, -1.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.0, 0.5 )\ny = base.dists.weibull.mgf( 0.2, 0.5, -1.0 )\ny = base.dists.weibull.mgf( 0.2, 0.5, 0.0 )\n",
- "base.dists.weibull.mode": "v = base.dists.weibull.mode( 1.0, 1.0 )\nv = base.dists.weibull.mode( 4.0, 12.0 )\nv = base.dists.weibull.mode( 8.0, 2.0 )\n",
- "base.dists.weibull.pdf": "y = base.dists.weibull.pdf( 2.0, 1.0, 0.5 )\ny = base.dists.weibull.pdf( 0.1, 1.0, 1.0 )\ny = base.dists.weibull.pdf( -1.0, 4.0, 2.0 )\ny = base.dists.weibull.pdf( NaN, 0.6, 1.0 )\ny = base.dists.weibull.pdf( 0.0, NaN, 1.0 )\ny = base.dists.weibull.pdf( 0.0, 0.0, NaN )\ny = base.dists.weibull.pdf( 2.0, 0.0, -1.0 )\n",
- "base.dists.weibull.quantile": "y = base.dists.weibull.quantile( 0.8, 1.0, 1.0 )\ny = base.dists.weibull.quantile( 0.5, 2.0, 4.0 )\ny = base.dists.weibull.quantile( 1.1, 1.0, 1.0 )\ny = base.dists.weibull.quantile( -0.2, 1.0, 1.0 )\ny = base.dists.weibull.quantile( NaN, 0.0, 1.0 )\ny = base.dists.weibull.quantile( 0.0, NaN, 1.0 )\ny = base.dists.weibull.quantile( 0.0, 0.0, NaN )\ny = base.dists.weibull.quantile( 0.5, 1.0, -1.0 )\n",
- "base.dists.weibull.skewness": "v = base.dists.weibull.skewness( 1.0, 1.0 )\nv = base.dists.weibull.skewness( 4.0, 12.0 )\nv = base.dists.weibull.skewness( 8.0, 2.0 )\n",
- "base.dists.weibull.stdev": "v = base.dists.weibull.stdev( 1.0, 1.0 )\nv = base.dists.weibull.stdev( 4.0, 12.0 )\nv = base.dists.weibull.stdev( 8.0, 2.0 )\n",
- "base.dists.weibull.variance": "v = base.dists.weibull.variance( 1.0, 1.0 )\nv = base.dists.weibull.variance( 4.0, 12.0 )\nv = base.dists.weibull.variance( 8.0, 2.0 )\n",
- "base.dists.weibull.Weibull": "weibull = base.dists.weibull.Weibull( 6.0, 5.0 );\nweibull.k\nweibull.lambda\nweibull.entropy\nweibull.kurtosis\nweibull.mean\nweibull.median\nweibull.mode\nweibull.skewness\nweibull.stdev\nweibull.variance\nweibull.cdf( 3.0 )\nweibull.logcdf( 3.0 )\nweibull.logpdf( 1.0 )\nweibull.mgf( -0.5 )\nweibull.pdf( 3.0 )\nweibull.quantile( 0.8 )\n",
- "base.ellipe": "y = base.ellipe( 0.5 )\ny = base.ellipe( -1.0 )\ny = base.ellipe( 2.0 )\ny = base.ellipe( PINF )\ny = base.ellipe( NINF )\ny = base.ellipe( NaN )\n",
- "base.ellipk": "y = base.ellipk( 0.5 )\ny = base.ellipk( -1.0 )\ny = base.ellipk( 2.0 )\ny = base.ellipk( PINF )\ny = base.ellipk( NINF )\ny = base.ellipk( NaN )\n",
- "base.epsdiff": "d = base.epsdiff( 12.15, 12.149999999999999 )\nd = base.epsdiff( 2.4341309458983933, 2.4341309458633909, 'mean-abs' )\n\n// Custom scale function:\nfunction scale( x, y ) { return ( x > y ) ? y : x; };\nd = base.epsdiff( 1.0000000000000002, 1.0000000000000100, scale )\n",
- "base.erf": "y = base.erf( 2.0 )\ny = base.erf( -1.0 )\ny = base.erf( -0.0 )\ny = base.erf( NaN )\n",
- "base.erfc": "y = base.erfc( 2.0 )\ny = base.erfc( -1.0 )\ny = base.erfc( 0.0 )\ny = base.erfc( PINF )\ny = base.erfc( NINF )\ny = base.erfc( NaN )\n",
- "base.erfcinv": "y = base.erfcinv( 0.5 )\ny = base.erfcinv( 0.8 )\ny = base.erfcinv( 0.0 )\ny = base.erfcinv( 2.0 )\ny = base.erfcinv( NaN )\n",
- "base.erfinv": "y = base.erfinv( 0.5 )\ny = base.erfinv( 0.8 )\ny = base.erfinv( 0.0 )\ny = base.erfinv( -0.0 )\ny = base.erfinv( -1.0 )\ny = base.erfinv( 1.0 )\ny = base.erfinv( NaN )\n",
- "base.eta": "y = base.eta( 0.0 )\ny = base.eta( -1.0 )\ny = base.eta( 1.0 )\ny = base.eta( 3.14 )\ny = base.eta( NaN )\n",
- "base.evalpoly": "arr = [ 3.0, 2.0, 1.0 ];\n\n// 3*10^0 + 2*10^1 + 1*10^2\nv = base.evalpoly( arr, 10.0 )\n",
- "base.evalrational": "\n// 2x^3 + 4x^2 - 5x^1 - 6x^0\nP = [ -6.0, -5.0, 4.0, 2.0 ];\n\n// 0.5x^1 + 3x^0\nQ = [ 3.0, 0.5, 0.0, 0.0 ]; // zero-padded\n\n// Evaluate the rational function:\nv = base.evalrational( P, Q, 6.0 )\n",
- "base.exp": "y = base.exp( 4.0 )\ny = base.exp( -9.0 )\ny = base.exp( 0.0 )\ny = base.exp( NaN )\n",
- "base.exp2": "y = base.exp2( 3.0 )\ny = base.exp2( -9.0 )\ny = base.exp2( 0.0 )\ny = base.exp2( NaN )\n",
- "base.exp10": "y = base.exp10( 3.0 )\ny = base.exp10( -9.0 )\ny = base.exp10( 0.0 )\ny = base.exp10( NaN )\n",
- "base.expit": "y = base.expit( 0.0 )\ny = base.expit( 1.0 )\ny = base.expit( -1.0 )\ny = base.expit( Infinity )\ny = base.expit( NaN )\n",
- "base.expm1": "y = base.expm1( 0.2 )\ny = base.expm1( -9.0 )\ny = base.expm1( 0.0 )\ny = base.expm1( NaN )\n",
- "base.expm1rel": "y = base.expm1rel( 0.0 )\ny = base.expm1rel( 1.0 )\ny = base.expm1rel( -1.0 )\ny = base.expm1rel( NaN )\n",
- "base.exponent": "exponent = base.exponent( 3.14e-307 )\nexponent = base.exponent( -3.14 )\nexponent = base.exponent( 0.0 )\nexponent = base.exponent( NaN )\n",
- "base.exponentf": "exponent = base.exponentf( base.float64ToFloat32( 3.14e34 ) )\nexponent = base.exponentf( base.float64ToFloat32( 3.14e-34 ) )\nexponent = base.exponentf( base.float64ToFloat32( -3.14 ) )\nexponent = base.exponentf( 0.0 )\nexponent = base.exponentf( NaN )\n",
- "base.factorial": "y = base.factorial( 3.0 )\ny = base.factorial( -1.5 )\ny = base.factorial( -0.5 )\ny = base.factorial( 0.5 )\ny = base.factorial( -10.0 )\ny = base.factorial( 171.0 )\ny = base.factorial( NaN )\n",
- "base.factorialln": "y = base.factorialln( 3.0 )\ny = base.factorialln( 2.4 )\ny = base.factorialln( -1.0 )\ny = base.factorialln( -1.5 )\ny = base.factorialln( NaN )\n",
- "base.fallingFactorial": "v = base.fallingFactorial( 0.9, 5 )\nv = base.fallingFactorial( -9.0, 3 )\nv = base.fallingFactorial( 0.0, 2 )\nv = base.fallingFactorial( 3.0, -2 )\n",
- "base.fibonacci": "y = base.fibonacci( 0 )\ny = base.fibonacci( 1 )\ny = base.fibonacci( 2 )\ny = base.fibonacci( 3 )\ny = base.fibonacci( 4 )\ny = base.fibonacci( 79 )\ny = base.fibonacci( NaN )\n",
- "base.fibonacciIndex": "n = base.fibonacciIndex( 2 )\nn = base.fibonacciIndex( 3 )\nn = base.fibonacciIndex( 5 )\nn = base.fibonacciIndex( NaN )\nn = base.fibonacciIndex( 1 )\n",
- "base.fibpoly": "\n// 2^4 + 3*2^2 + 1\nv = base.fibpoly( 5, 2.0 )\n",
- "base.flipsign": "z = base.flipsign( -3.14, 10.0 )\nz = base.flipsign( -3.14, -1.0 )\nz = base.flipsign( 1.0, -0.0 )\nz = base.flipsign( -3.14, -0.0 )\nz = base.flipsign( -0.0, 1.0 )\nz = base.flipsign( 0.0, -1.0 )\n",
- "base.float32ToInt32": "y = base.float32ToInt32( base.float64ToFloat32( 4294967295.0 ) )\ny = base.float32ToInt32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToInt32( base.float64ToFloat32( NaN ) )\ny = base.float32ToInt32( FLOAT32_PINF )\ny = base.float32ToInt32( FLOAT32_NINF )\n",
- "base.float32ToUint32": "y = base.float32ToUint32( base.float64ToFloat32( 4294967297.0 ) )\ny = base.float32ToUint32( base.float64ToFloat32( 3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( -3.14 ) )\ny = base.float32ToUint32( base.float64ToFloat32( NaN ) )\ny = base.float32ToUint32( FLOAT32_PINF )\ny = base.float32ToUint32( FLOAT32_NINF )\n",
- "base.float64ToFloat32": "y = base.float64ToFloat32( 1.337 )\n",
- "base.float64ToInt32": "y = base.float64ToInt32( 4294967295.0 )\ny = base.float64ToInt32( 3.14 )\ny = base.float64ToInt32( -3.14 )\ny = base.float64ToInt32( NaN )\ny = base.float64ToInt32( PINF )\ny = base.float64ToInt32( NINF )\n",
- "base.float64ToUint32": "y = base.float64ToUint32( 4294967297.0 )\ny = base.float64ToUint32( 3.14 )\ny = base.float64ToUint32( -3.14 )\ny = base.float64ToUint32( NaN )\ny = base.float64ToUint32( PINF )\ny = base.float64ToUint32( NINF )\n",
- "base.floor": "y = base.floor( 3.14 )\ny = base.floor( -4.2 )\ny = base.floor( -4.6 )\ny = base.floor( 9.5 )\ny = base.floor( -0.0 )\n",
- "base.floor2": "y = base.floor2( 3.14 )\ny = base.floor2( -4.2 )\ny = base.floor2( -4.6 )\ny = base.floor2( 9.5 )\ny = base.floor2( 13.0 )\ny = base.floor2( -13.0 )\ny = base.floor2( -0.0 )\n",
- "base.floor10": "y = base.floor10( 3.14 )\ny = base.floor10( -4.2 )\ny = base.floor10( -4.6 )\ny = base.floor10( 9.5 )\ny = base.floor10( 13.0 )\ny = base.floor10( -13.0 )\ny = base.floor10( -0.0 )\n",
- "base.floorb": "\n// Round to 4 decimal places:\ny = base.floorb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.floorb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward negative infinity:\ny = base.floorb( 5.0, 1, 2 )\n",
- "base.floorn": "\n// Round to 4 decimal places:\ny = base.floorn( 3.14159, -4 )\n\n// If `n = 0`, standard round toward negative infinity behavior:\ny = base.floorn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.floorn( 12368.0, 3 )\n",
- "base.floorsd": "y = base.floorsd( 3.14159, 5 )\ny = base.floorsd( 3.14159, 1 )\ny = base.floorsd( 12368.0, 2 )\ny = base.floorsd( 0.0313, 2, 2 )\n",
- "base.fresnel": "y = base.fresnel( 0.0 )\ny = base.fresnel( 1.0 )\ny = base.fresnel( PINF )\ny = base.fresnel( NINF )\ny = base.fresnel( NaN )\nout = new Float64Array( 2 );\nv = base.fresnel( out, 0.0 )\nbool = ( v === out )\n",
- "base.fresnelc": "y = base.fresnelc( 0.0 )\ny = base.fresnelc( 1.0 )\ny = base.fresnelc( PINF )\ny = base.fresnelc( NINF )\ny = base.fresnelc( NaN )\n",
- "base.fresnels": "y = base.fresnels( 0.0 )\ny = base.fresnels( 1.0 )\ny = base.fresnels( PINF )\ny = base.fresnels( NINF )\ny = base.fresnels( NaN )\n",
- "base.frexp": "out = base.frexp( 4.0 )\nout = base.frexp( 0.0 )\nout = base.frexp( -0.0 )\nout = base.frexp( NaN )\nout = base.frexp( PINF )\nout = base.frexp( NINF )\n\n// Provide an output array:\nout = new Float64Array( 2 );\ny = base.frexp( out, 4.0 )\nbool = ( y === out )\n",
- "base.fromBinaryString": "bstr;\nbstr = '0100000000010000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0100000000001001001000011111101101010100010001000010110100011000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111100001110011001111001110000101111010111100100010100000';\nval = base.fromBinaryString( bstr )\n\n// The function handles subnormals:\nbstr = '1000000000000000000000000000000000000000000000000001100011010011';\nval = base.fromBinaryString( bstr )\nbstr = '0000000000000000000000000000000000000000000000000000000000000001';\nval = base.fromBinaryString( bstr )\n\n// The function handles special values:\nbstr = '0000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1000000000000000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111111000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '0111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\nbstr = '1111111111110000000000000000000000000000000000000000000000000000';\nval = base.fromBinaryString( bstr )\n",
- "base.fromBinaryStringf": "bstr = '01000000100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01000000010010010000111111011011';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111011011000011101000110011';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles subnormals:\nbstr = '10000000000000000000000000010110';\nval = base.fromBinaryStringf( bstr )\nbstr = '00000000000000000000000000000001';\nval = base.fromBinaryStringf( bstr )\n\n// The function handles special values:\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '10000000000000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111110000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '01111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\nbstr = '11111111100000000000000000000000';\nval = base.fromBinaryStringf( bstr )\n",
- "base.fromBinaryStringUint8": "bstr = '01010101';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '00000000';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '00000010';\nval = base.fromBinaryStringUint8( bstr )\nbstr = '11111111';\nval = base.fromBinaryStringUint8( bstr )\n",
- "base.fromBinaryStringUint16": "bstr = '0101010101010101';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000000';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '0000000000000010';\nval = base.fromBinaryStringUint16( bstr )\nbstr = '1111111111111111';\nval = base.fromBinaryStringUint16( bstr )\n",
- "base.fromBinaryStringUint32": "bstr = '01010101010101010101010101010101';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000000';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '00000000000000000000000000000010';\nval = base.fromBinaryStringUint32( bstr )\nbstr = '11111111111111111111111111111111';\nval = base.fromBinaryStringUint32( bstr )\n",
- "base.fromWordf": "word = 1068180177; // => 0 01111111 01010110010001011010001\nf32 = base.fromWordf( word ) // when printed, promoted to float64\n",
- "base.fromWords": "v = base.fromWords( 1774486211, 2479577218 )\nv = base.fromWords( 3221823995, 1413754136 )\nv = base.fromWords( 0, 0 )\nv = base.fromWords( 2147483648, 0 )\nv = base.fromWords( 2146959360, 0 )\nv = base.fromWords( 2146435072, 0 )\nv = base.fromWords( 4293918720, 0 )\n",
- "base.gamma": "y = base.gamma( 4.0 )\ny = base.gamma( -1.5 )\ny = base.gamma( -0.5 )\ny = base.gamma( 0.5 )\ny = base.gamma( 0.0 )\ny = base.gamma( -0.0 )\ny = base.gamma( NaN )\n",
- "base.gamma1pm1": "y = base.gamma1pm1( 0.2 )\ny = base.gamma1pm1( -6.7 )\ny = base.gamma1pm1( 0.0 )\ny = base.gamma1pm1( NaN )\n",
- "base.gammaDeltaRatio": "y = base.gammaDeltaRatio( 2.0, 3.0 )\ny = base.gammaDeltaRatio( 4.0, 0.5 )\ny = base.gammaDeltaRatio( 100.0, 0.0 )\ny = base.gammaDeltaRatio( NaN, 3.0 )\ny = base.gammaDeltaRatio( 5.0, NaN )\ny = base.gammaDeltaRatio( NaN, NaN )\n",
- "base.gammainc": "y = base.gammainc( 6.0, 2.0 )\ny = base.gammainc( 1.0, 2.0, true, true )\ny = base.gammainc( 7.0, 5.0 )\ny = base.gammainc( 7.0, 5.0, false )\ny = base.gammainc( NaN, 2.0 )\ny = base.gammainc( 6.0, NaN )\n",
- "base.gammaincinv": "y = base.gammaincinv( 0.5, 2.0 )\ny = base.gammaincinv( 0.1, 10.0 )\ny = base.gammaincinv( 0.75, 3.0 )\ny = base.gammaincinv( 0.75, 3.0, true )\ny = base.gammaincinv( 0.75, NaN )\ny = base.gammaincinv( NaN, 3.0 )\n",
- "base.gammaLanczosSum": "y = base.gammaLanczosSum( 4.0 )\ny = base.gammaLanczosSum( -1.5 )\ny = base.gammaLanczosSum( -0.5 )\ny = base.gammaLanczosSum( 0.5 )\ny = base.gammaLanczosSum( 0.0 )\ny = base.gammaLanczosSum( NaN )\n",
- "base.gammaLanczosSumExpGScaled": "y = base.gammaLanczosSumExpGScaled( 4.0 )\ny = base.gammaLanczosSumExpGScaled( -1.5 )\ny = base.gammaLanczosSumExpGScaled( -0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.5 )\ny = base.gammaLanczosSumExpGScaled( 0.0 )\ny = base.gammaLanczosSumExpGScaled( NaN )\n",
- "base.gammaln": "y = base.gammaln( 1.0 )\ny = base.gammaln( 2.0 )\ny = base.gammaln( 4.0 )\ny = base.gammaln( -0.5 )\ny = base.gammaln( 0.5 )\ny = base.gammaln( 0.0 )\ny = base.gammaln( NaN )\n",
- "base.gasum": "\n// Standard usage:\nx = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];\nsum = base.gasum( x.length, x, 1 )\n\n// Sum every other value:\nN = base.floor( x.length / 2 );\nstride = 2;\nsum = base.gasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nx0 = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.gasum( N, x1, stride )\n",
- "base.gaxpy": "\n// Standard usage:\nx = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\ny = [ 1.0, 1.0, 1.0, 1.0, 1.0 ];\nalpha = 5.0;\nbase.gaxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nN = base.floor( x.length / 2 );\nbase.gaxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nx0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gaxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n",
- "base.gcd": "v = base.gcd( 48, 18 )\n",
- "base.gcopy": "\n// Standard usage:\nx = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\ny = [ 6.0, 7.0, 8.0, 9.0, 10.0 ];\nbase.gcopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\ny = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\nN = base.floor( x.length / 2 );\nbase.gcopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nx0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.gcopy( N, x1, -2, y1, 1 )\ny0\n",
- "base.getHighWord": "w = base.getHighWord( 3.14e201 )\n",
- "base.getLowWord": "w = base.getLowWord( 3.14e201 )\n",
- "base.hacovercos": "y = base.hacovercos( 3.14 )\ny = base.hacovercos( -4.2 )\ny = base.hacovercos( -4.6 )\ny = base.hacovercos( 9.5 )\ny = base.hacovercos( -0.0 )\n",
- "base.hacoversin": "y = base.hacoversin( 3.14 )\ny = base.hacoversin( -4.2 )\ny = base.hacoversin( -4.6 )\ny = base.hacoversin( 9.5 )\ny = base.hacoversin( -0.0 )\n",
- "base.havercos": "y = base.havercos( 3.14 )\ny = base.havercos( -4.2 )\ny = base.havercos( -4.6 )\ny = base.havercos( 9.5 )\ny = base.havercos( -0.0 )\n",
- "base.haversin": "y = base.haversin( 3.14 )\ny = base.haversin( -4.2 )\ny = base.haversin( -4.6 )\ny = base.haversin( 9.5 )\ny = base.haversin( -0.0 )\n",
- "base.heaviside": "y = base.heaviside( 3.14 )\ny = base.heaviside( -3.14 )\ny = base.heaviside( 0.0 )\ny = base.heaviside( 0.0, 'half-maximum' )\ny = base.heaviside( 0.0, 'left-continuous' )\ny = base.heaviside( 0.0, 'right-continuous' )\n",
- "base.hermitepoly": "y = base.hermitepoly( 1, 0.5 )\ny = base.hermitepoly( -1, 0.5 )\ny = base.hermitepoly( 0, 0.5 )\ny = base.hermitepoly( 2, 0.5 )\n",
- "base.hypot": "h = base.hypot( -5.0, 12.0 )\nh = base.hypot( NaN, 12.0 )\nh = base.hypot( -0.0, -0.0 )\n",
- "base.imul": "v = base.imul( -10|0, 4|0 )\n",
- "base.imuldw": "v = base.imuldw( 1, 10 )\n",
- "base.int32ToUint32": "y = base.int32ToUint32( base.float64ToInt32( -32 ) )\ny = base.int32ToUint32( base.float64ToInt32( 3 ) )\n",
- "base.inv": "y = base.inv( -1.0 )\ny = base.inv( 2.0 )\ny = base.inv( 0.0 )\ny = base.inv( -0.0 )\ny = base.inv( NaN )\n",
- "base.isEven": "bool = base.isEven( 5.0 )\nbool = base.isEven( -2.0 )\nbool = base.isEven( 0.0 )\nbool = base.isEven( NaN )\n",
- "base.isEvenInt32": "bool = base.isEvenInt32( 5 )\nbool = base.isEvenInt32( -2 )\nbool = base.isEvenInt32( 0 )\n",
- "base.isFinite": "bool = base.isFinite( 5.0 )\nbool = base.isFinite( -2.0e64 )\nbool = base.isFinite( PINF )\nbool = base.isFinite( NINF )\n",
- "base.isInfinite": "bool = base.isInfinite( PINF )\nbool = base.isInfinite( NINF )\nbool = base.isInfinite( 5.0 )\nbool = base.isInfinite( NaN )\n",
- "base.isInteger": "bool = base.isInteger( 1.0 )\nbool = base.isInteger( 3.14 )\n",
- "base.isnan": "bool = base.isnan( NaN )\nbool = base.isnan( 7.0 )\n",
- "base.isNegativeInteger": "bool = base.isNegativeInteger( -1.0 )\nbool = base.isNegativeInteger( 0.0 )\nbool = base.isNegativeInteger( 10.0 )\n",
- "base.isNegativeZero": "bool = base.isNegativeZero( -0.0 )\nbool = base.isNegativeZero( 0.0 )\n",
- "base.isNonNegativeInteger": "bool = base.isNonNegativeInteger( 1.0 )\nbool = base.isNonNegativeInteger( 0.0 )\nbool = base.isNonNegativeInteger( -10.0 )\n",
- "base.isNonPositiveInteger": "bool = base.isNonPositiveInteger( -1.0 )\nbool = base.isNonPositiveInteger( 0.0 )\nbool = base.isNonPositiveInteger( 10.0 )\n",
- "base.isOdd": "bool = base.isOdd( 5.0 )\nbool = base.isOdd( -2.0 )\nbool = base.isOdd( 0.0 )\nbool = base.isOdd( NaN )\n",
- "base.isOddInt32": "bool = base.isOddInt32( 5 )\nbool = base.isOddInt32( -2 )\nbool = base.isOddInt32( 0 )\n",
- "base.isPositiveInteger": "bool = base.isPositiveInteger( 1.0 )\nbool = base.isPositiveInteger( 0.0 )\nbool = base.isPositiveInteger( -10.0 )\n",
- "base.isPositiveZero": "bool = base.isPositiveZero( 0.0 )\nbool = base.isPositiveZero( -0.0 )\n",
- "base.isPow2Uint32": "bool = base.isPow2Uint32( 2 )\nbool = base.isPow2Uint32( 5 )\n",
- "base.isProbability": "bool = base.isProbability( 0.5 )\nbool = base.isProbability( 3.14 )\nbool = base.isProbability( NaN )\n",
- "base.isSafeInteger": "bool = base.isSafeInteger( 1.0 )\nbool = base.isSafeInteger( 2.0e200 )\nbool = base.isSafeInteger( 3.14 )\n",
- "base.kernelBetainc": "out = base.kernelBetainc( 0.8, 1.0, 0.3, false, false )\nout = base.kernelBetainc( 0.2, 1.0, 2.0, true, false )\nout = new Array( 2 );\nv = base.kernelBetainc( out, 0.2, 1.0, 2.0, true, true )\nbool = ( v === out )\n",
- "base.kernelBetaincinv": "y = base.kernelBetaincinv( 3.0, 3.0, 0.2, 0.8 )\ny = base.kernelBetaincinv( 3.0, 3.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.4, 0.6 )\ny = base.kernelBetaincinv( 1.0, 6.0, 0.8, 0.2 )\n",
- "base.kernelCos": "out = base.kernelCos( 0.0, 0.0 )\nout = base.kernelCos( PI/6.0, 0.0 )\nout = base.kernelCos( 0.785, -1.144e-17 )\nout = base.kernelCos( NaN )\n",
- "base.kernelSin": "y = base.kernelSin( 0.0, 0.0 )\ny = base.kernelSin( PI/6.0, 0.0 )\ny = base.kernelSin( 0.619, 9.279e-18 )\ny = base.kernelSin( NaN, 0.0 )\ny = base.kernelSin( 2.0, NaN )\ny = base.kernelSin( NaN, NaN )\n",
- "base.kernelTan": "out = base.kernelTan( PI/4.0, 0.0, 1 )\nout = base.kernelTan( PI/4.0, 0.0, -1 )\nout = base.kernelTan( PI/6.0, 0.0, 1 )\nout = base.kernelTan( 0.664, 5.288e-17, 1 )\nout = base.kernelTan( NaN, 0.0, 1 )\nout = base.kernelTan( 3.0, NaN, 1 )\nout = base.kernelTan( 3.0, 0.0, NaN )\n",
- "base.kroneckerDelta": "y = base.kroneckerDelta( 3.14, 0.0 )\ny = base.kroneckerDelta( 3.14, 3.14 )\n",
- "base.lcm": "v = base.lcm( 21, 6 )\n",
- "base.ldexp": "x = base.ldexp( 0.5, 3 )\nx = base.ldexp( 4.0, -2 )\nx = base.ldexp( 0.0, 20 )\nx = base.ldexp( -0.0, 39 )\nx = base.ldexp( NaN, -101 )\nx = base.ldexp( PINF, 11 )\nx = base.ldexp( NINF, -118 )\n",
- "base.ln": "y = base.ln( 4.0 )\ny = base.ln( 0.0 )\ny = base.ln( PINF )\ny = base.ln( NaN )\ny = base.ln( -4.0 )\n",
- "base.log": "y = base.log( 100.0, 10.0 )\ny = base.log( 16.0, 2.0 )\ny = base.log( 5.0, 1.0 )\ny = base.log( NaN, 2.0 )\ny = base.log( 1.0, NaN )\ny = base.log( -4.0, 2.0 )\ny = base.log( 4.0, -2.0 )\n",
- "base.log1mexp": "y = base.log1mexp( -10.0 )\ny = base.log1mexp( 0.0 )\ny = base.log1mexp( 5.0 )\ny = base.log1mexp( 10.0 )\ny = base.log1mexp( NaN )\n",
- "base.log1p": "y = base.log1p( 4.0 )\ny = base.log1p( -1.0 )\ny = base.log1p( 0.0 )\ny = base.log1p( -0.0 )\ny = base.log1p( -2.0 )\ny = base.log1p( NaN )\n",
- "base.log1pexp": "y = base.log1pexp( -10.0 )\ny = base.log1pexp( 0.0 )\ny = base.log1pexp( 5.0 )\ny = base.log1pexp( 34.0 )\ny = base.log1pexp( NaN )\n",
- "base.log2": "y = base.log2( 4.0 )\ny = base.log2( 8.0 )\ny = base.log2( 0.0 )\ny = base.log2( PINF )\ny = base.log2( NaN )\ny = base.log2( -4.0 )\n",
- "base.log10": "y = base.log10( 100.0 )\ny = base.log10( 8.0 )\ny = base.log10( 0.0 )\ny = base.log10( PINF )\ny = base.log10( NaN )\ny = base.log10( -4.0 )\n",
- "base.logaddexp": "v = base.logaddexp( 90.0, 90.0 )\nv = base.logaddexp( -20.0, 90.0 )\nv = base.logaddexp( 0.0, -100.0 )\nv = base.logaddexp( NaN, NaN )\n",
- "base.logit": "y = base.logit( 0.2 )\ny = base.logit( 0.9 )\ny = base.logit( -4.0 )\ny = base.logit( 1.5 )\ny = base.logit( NaN )\n",
- "base.lucas": "y = base.lucas( 0 )\ny = base.lucas( 1 )\ny = base.lucas( 2 )\ny = base.lucas( 3 )\ny = base.lucas( 4 )\ny = base.lucas( 77 )\ny = base.lucas( NaN )\n",
- "base.lucaspoly": "\n// 2^5 + 5*2^3 + 5*2\nv = base.lucaspoly( 5, 2.0 )\n",
- "base.max": "v = base.max( 3.14, 4.2 )\nv = base.max( 5.9, 3.14, 4.2 )\nv = base.max( 3.14, NaN )\nv = base.max( +0.0, -0.0 )\n",
- "base.maxabs": "v = base.maxabs( 3.14, -4.2 )\nv = base.maxabs( 5.9, 3.14, 4.2 )\nv = base.maxabs( 3.14, NaN )\nv = base.maxabs( +0.0, -0.0 )\n",
- "base.min": "v = base.min( 3.14, 4.2 )\nv = base.min( 5.9, 3.14, 4.2 )\nv = base.min( 3.14, NaN )\nv = base.min( +0.0, -0.0 )\n",
- "base.minabs": "v = base.minabs( 3.14, -4.2 )\nv = base.minabs( 5.9, 3.14, 4.2 )\nv = base.minabs( 3.14, NaN )\nv = base.minabs( +0.0, -0.0 )\n",
- "base.minmax": "v = base.minmax( 3.14, 4.2 )\nv = base.minmax( 5.9, 3.14, 4.2 )\nv = base.minmax( 3.14, NaN )\nv = base.minmax( +0.0, -0.0 )\nv = base.minmax( 3.14 )\nout = new Array( 2 );\nv = base.minmax( out, 3.14 )\nbool = ( v === out )\n",
- "base.minmaxabs": "v = base.minmaxabs( 3.14, 4.2 )\nv = base.minmaxabs( -5.9, 3.14, 4.2 )\nv = base.minmaxabs( 3.14, NaN )\nv = base.minmaxabs( +0.0, -0.0 )\nv = base.minmaxabs( 3.14 )\nout = new Array( 2 );\nv = base.minmaxabs( out, 3.14 )\nbool = ( v === out )\n",
- "base.modf": "parts = base.modf( 3.14 )\nparts = base.modf( 3.14 )\nparts = base.modf( +0.0 )\nparts = base.modf( -0.0 )\nparts = base.modf( PINF )\nparts = base.modf( NINF )\nparts = base.modf( NaN )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nparts = base.modf( out, 3.14 )\nbool = ( parts === out )\n",
- "base.ndarray": "ctor = base.ndarray( 'float64', 3 )\n\n// To create a new instance...\nb = [ 1, 2, 3, 4 ]; // underlying data buffer\nd = [ 2, 2 ]; // shape\ns = [ 2, 1 ]; // strides\no = 0; // index offset\narr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nv = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n",
- "base.ndarrayMemoized": "ctor = base.ndarrayMemoized( 'float64', 3 )\nf = base.ndarrayMemoized( 'float64', 3 )\nbool = ( f === ctor )\n\n// To create a new instance...\nb = [ 1, 2, 3, 4 ]; // underlying data buffer\nd = [ 2, 2 ]; // shape\ns = [ 2, 1 ]; // strides\no = 0; // index offset\narr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nv = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99 );\narr.get( 1, 1 )\n",
- "base.negafibonacci": "y = base.negafibonacci( 0 )\ny = base.negafibonacci( -1 )\ny = base.negafibonacci( -2 )\ny = base.negafibonacci( -3 )\ny = base.negafibonacci( -4 )\ny = base.negafibonacci( -79 )\ny = base.negafibonacci( -80 )\ny = base.negafibonacci( NaN )\n",
- "base.negalucas": "y = base.negalucas( 0 )\ny = base.negalucas( -1 )\ny = base.negalucas( -2 )\ny = base.negalucas( -3 )\ny = base.negalucas( -4 )\ny = base.negalucas( -77 )\ny = base.negalucas( -78 )\ny = base.negalucas( NaN )\n",
- "base.nonfibonacci": "v = base.nonfibonacci( 1 )\nv = base.nonfibonacci( 2 )\nv = base.nonfibonacci( 3 )\nv = base.nonfibonacci( NaN )\n",
- "base.normalize": "out = base.normalize( 3.14e-319 )\ny = out[ 0 ];\nexponent = out[ 1 ];\nbool = ( y*base.pow(2.0, exponent) === 3.14e-319 )\n\n// Special cases:\nout = base.normalize( 0.0 )\nout = base.normalize( PINF )\nout = base.normalize( NINF )\nout = base.normalize( NaN )\n\n// Provide an output array:\nout = new Float64Array( 2 );\nv = base.normalize( out, 3.14e-319 )\nbool = ( v === out )\n",
- "base.normalizef": "out = base.normalizef( base.float64ToFloat32( 1.401e-45 ) )\ny = out[ 0 ];\nexp = out[ 1 ];\nbool = ( y*base.pow(2,exp) === base.float64ToFloat32(1.401e-45) )\n\n// Special cases:\nout = base.normalizef( FLOAT32_PINF )\nout = base.normalizef( FLOAT32_NINF )\nout = base.normalizef( NaN )\n\n// Provide an output array:\nout = new Float32Array( 2 );\nv = base.normalizef( out, base.float64ToFloat32( 1.401e-45 ) )\nbool = ( v === out )\n",
- "base.normhermitepoly": "y = base.normhermitepoly( 1, 0.5 )\ny = base.normhermitepoly( -1, 0.5 )\ny = base.normhermitepoly( 0, 0.5 )\ny = base.normhermitepoly( 2, 0.5 )\n",
- "base.pdiff": "v = base.pdiff( 5.9, 3.14 )\nv = base.pdiff( 3.14, 4.2 )\nv = base.pdiff( 3.14, NaN )\nv = base.pdiff( -0.0, +0.0 )\n",
- "base.polygamma": "v = base.polygamma( 3, 1.2 )\nv = base.polygamma( 5, 1.2 )\nv = base.polygamma( 3, -4.9 )\nv = base.polygamma( -1, 5.3 )\nv = base.polygamma( 2, -1.0 )\n",
- "base.pow": "y = base.pow( 2.0, 3.0 )\ny = base.pow( 4.0, 0.5 )\ny = base.pow( 100.0, 0.0 )\ny = base.pow( PI, 5.0 )\ny = base.pow( PI, -0.2 )\ny = base.pow( NaN, 3.0 )\ny = base.pow( 5.0, NaN )\ny = base.pow( NaN, NaN )\n",
- "base.powm1": "y = base.powm1( 2.0, 3.0 )\ny = base.powm1( 4.0, 0.5 )\ny = base.powm1( 0.0, 100.0 )\ny = base.powm1( 100.0, 0.0 )\ny = base.powm1( 0.0, 0.0 )\ny = base.powm1( PI, 5.0 )\ny = base.powm1( NaN, 3.0 )\ny = base.powm1( 5.0, NaN )\n",
- "base.rad2deg": "d = base.rad2deg( PI/2.0 )\nd = base.rad2deg( -PI/4.0 )\nd = base.rad2deg( NaN )\n\n// Due to finite precision, canonical values may not be returned:\nd = base.rad2deg( PI/6.0 )\n",
- "base.ramp": "y = base.ramp( 3.14 )\ny = base.ramp( -3.14 )\n",
- "base.random.arcsine": "r = base.random.arcsine( 2.0, 5.0 )\n",
- "base.random.bernoulli": "r = base.random.bernoulli( 0.8 );\n",
- "base.random.beta": "r = base.random.beta( 2.0, 5.0 );\n",
- "base.random.betaprime": "r = base.random.betaprime( 2.0, 5.0 );\n",
- "base.random.binomial": "r = base.random.binomial( 20, 0.8 );\n",
- "base.random.boxMuller": "r = base.random.boxMuller();\n",
- "base.random.cauchy": "r = base.random.cauchy( 2.0, 5.0 );\n",
- "base.random.chi": "r = base.random.chi( 2 );\n",
- "base.random.chisquare": "r = base.random.chisquare( 2 );\n",
- "base.random.cosine": "r = base.random.cosine( 2.0, 5.0 );\n",
- "base.random.discreteUniform": "r = base.random.discreteUniform( 2, 50 );\n",
- "base.random.erlang": "r = base.random.erlang( 2, 5.0 );\n",
- "base.random.exponential": "r = base.random.exponential( 7.9 );\n",
- "base.random.f": "r = base.random.f( 2.0, 5.0 );\n",
- "base.random.frechet": "r = base.random.frechet( 2.0, 5.0, 3.33 );\n",
- "base.random.gamma": "r = base.random.gamma( 2.0, 5.0 );\n",
- "base.random.geometric": "r = base.random.geometric( 0.8 );\n",
- "base.random.gumbel": "r = base.random.gumbel( 2.0, 5.0 );\n",
- "base.random.hypergeometric": "r = base.random.hypergeometric( 20, 10, 7 );\n",
- "base.random.improvedZiggurat": "r = base.random.improvedZiggurat();\n",
- "base.random.invgamma": "r = base.random.invgamma( 2.0, 5.0 );\n",
- "base.random.kumaraswamy": "r = base.random.kumaraswamy( 2.0, 5.0 );\n",
- "base.random.laplace": "r = base.random.laplace( 2.0, 5.0 );\n",
- "base.random.levy": "r = base.random.levy( 2.0, 5.0 );\n",
- "base.random.logistic": "r = base.random.logistic( 2.0, 5.0 );\n",
- "base.random.lognormal": "r = base.random.lognormal( 2.0, 5.0 );\n",
- "base.random.minstd": "r = base.random.minstd();\n",
- "base.random.minstdShuffle": "r = base.random.minstdShuffle();\n",
- "base.random.mt19937": "r = base.random.mt19937();\n",
- "base.random.negativeBinomial": "r = base.random.negativeBinomial( 20, 0.8 );\n",
- "base.random.normal": "r = base.random.normal( 2.0, 5.0 );\n",
- "base.random.pareto1": "r = base.random.pareto1( 2.0, 5.0 );\n",
- "base.random.poisson": "r = base.random.poisson( 7.9 );\n",
- "base.random.randi": "r = base.random.randi();\n",
- "base.random.randn": "r = base.random.randn();\n",
- "base.random.randu": "r = base.random.randu();\n",
- "base.random.rayleigh": "r = base.random.rayleigh( 2.5 );\n",
- "base.random.t": "r = base.random.t( 2.0 );\n",
- "base.random.triangular": "r = base.random.triangular( 2.0, 5.0, 3.33 );\n",
- "base.random.uniform": "r = base.random.uniform( 2.0, 5.0 );\n",
- "base.random.weibull": "r = base.random.weibull( 2.0, 5.0 );\n",
- "base.reldiff": "d = base.reldiff( 2.0, 5.0 )\nd = base.reldiff( -1.0, 3.14 )\nd = base.reldiff( -2.0, 5.0, 'max-abs' )\nd = base.reldiff( -2.0, 5.0, 'max' )\nd = base.reldiff( -2.0, 5.0, 'min-abs' )\nd = base.reldiff( -2.0, 5.0, 'min' )\nd = base.reldiff( -2.0, 5.0, 'mean-abs' )\nd = base.reldiff( -2.0, 5.0, 'mean' )\nd = base.reldiff( -2.0, 5.0, 'x' )\nd = base.reldiff( 5.0, -2.0, 'x' )\nd = base.reldiff( -2.0, 5.0, 'y' )\nd = base.reldiff( 5.0, -2.0, 'y' )\n\n// Custom scale function:\nfunction scale( x, y ) {\n var s;\n ...\n x = base.abs( x );\n y = base.abs( y );\n ...\n // Maximum absolute value:\n s = (x < y ) ? y : x;\n ...\n // Scale in units of epsilon:\n return s * EPS;\n};\nd = base.reldiff( 12.15, 12.149999999999999, scale )\n",
- "base.rempio2": "y = new Array( 2 );\nn = base.rempio2( 128.0, y )\ny1 = y[ 0 ]\ny2 = y[ 1 ]\n",
- "base.risingFactorial": "v = base.risingFactorial( 0.9, 5 )\nv = base.risingFactorial( -9.0, 3 )\nv = base.risingFactorial( 0.0, 2 )\nv = base.risingFactorial( 3.0, -2 )\n",
- "base.rotl32": "x = 2147483649;\nbStr = base.toBinaryStringUint32( x )\ny = base.rotl32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n",
- "base.rotr32": "x = 1;\nbStr = base.toBinaryStringUint32( x )\ny = base.rotr32( x, 10 )\nbstr = base.toBinaryStringUint32( y )\n",
- "base.round": "y = base.round( 3.14 )\ny = base.round( -4.2 )\ny = base.round( -4.6 )\ny = base.round( 9.5 )\ny = base.round( -0.0 )\n",
- "base.round2": "y = base.round2( 3.14 )\ny = base.round2( -4.2 )\ny = base.round2( -4.6 )\ny = base.round2( 9.5 )\ny = base.round2( 13.0 )\ny = base.round2( -13.0 )\ny = base.round2( -0.0 )\n",
- "base.round10": "y = base.round10( 3.14 )\ny = base.round10( -4.2 )\ny = base.round10( -4.6 )\ny = base.round10( 9.5 )\ny = base.round10( 13.0 )\ny = base.round10( -13.0 )\ny = base.round10( -0.0 )\n",
- "base.roundb": "\n// Round to 2 decimal places:\ny = base.roundb( 3.14159, -2, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.roundb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two:\ny = base.roundb( 5.0, 1, 2 )\n",
- "base.roundn": "\n// Round to 2 decimal places:\ny = base.roundn( 3.14159, -2 )\n\n// If `n = 0`, standard round behavior:\ny = base.roundn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.roundn( 12368.0, 3 )\n",
- "base.roundsd": "y = base.roundsd( 3.14159, 3 )\ny = base.roundsd( 3.14159, 1 )\ny = base.roundsd( 12368.0, 2 )\ny = base.roundsd( 0.0313, 2, 2 )\n",
- "base.rsqrt": "y = base.rsqrt( 4.0 )\ny = base.rsqrt( 100.0 )\ny = base.rsqrt( 0.0 )\ny = base.rsqrt( Infinity )\ny = base.rsqrt( -4.0 )\ny = base.rsqrt( NaN )\n",
- "base.sasum": "\n// Standard usage:\nx = new Float32Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\nsum = base.sasum( x.length, x, 1 )\n\n// Sum every other value:\nN = base.floor( x.length / 2 );\nstride = 2;\nsum = base.sasum( N, x, stride )\n\n// Use view offset; e.g., starting at 2nd element:\nx0 = new Float32Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\nx1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\nN = base.floor( x0.length / 2 );\nsum = base.sasum( N, x1, stride )\n",
- "base.saxpy": "\n// Standard usage:\nx = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\ny = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\nalpha = 5.0;\nbase.saxpy( x.length, alpha, x, 1, y, 1 )\n\n// Using `N` and `stride` parameters:\nN = base.floor( x.length / 2 );\nbase.saxpy( N, alpha, x, 2, y, -1 )\n\n// Using view offsets:\nx0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.saxpy( N, 5.0, x1, -2, y1, 1 )\ny0\n",
- "base.scopy": "\n// Standard usage:\nx = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\ny = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\nbase.scopy( x.length, x, 1, y, 1 )\n\n// Advanced indexing:\nx = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nN = base.floor( x.length / 2 );\nbase.scopy( N, x, -2, y, 1 )\n\n// Using typed array views:\nx0 = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\ny0 = new Float32Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\nx1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\ny1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\nN = base.floor( x0.length / 2 );\nbase.scopy( N, x1, -2, y1, 1 )\ny0\n",
- "base.setHighWord": "\n// Set the higher order bits of `+infinity` to return `1`:\nhigh = 1072693248 >>> 0;\ny = base.setHighWord( PINF, high )\n",
- "base.setLowWord": "low = 5 >>> 0;\nx = 3.14e201;\ny = base.setLowWord( x, low )\n\n// Special cases:\nlow = 12345678;\ny = base.setLowWord( PINF, low )\ny = base.setLowWord( NINF, low )\ny = base.setLowWord( NaN, low )\n",
- "base.sici": "y = base.sici( 3.0 )\ny = base.sici( 0.0 )\ny = base.sici( -9.0 )\ny = base.sici( NaN )\n\n// Provide an output array:\nout = new Float64Array( 2 );\ny = base.sici( out, 3.0 )\nbool = ( y === out )\n",
- "base.signbit": "bool = base.signbit( 4.0 )\nbool = base.signbit( -9.14e-34 )\nbool = base.signbit( 0.0 )\nbool = base.signbit( -0.0 )\n",
- "base.signbitf": "bool = base.signbitf( base.float64ToFloat32( 4.0 ) )\nbool = base.signbitf( base.float64ToFloat32( -9.14e-34 ) )\nbool = base.signbitf( 0.0 )\nbool = base.signbitf( -0.0 )\n",
- "base.significandf": "s = base.significandf( base.float64ToFloat32( 3.14e34 ) )\ns = base.significandf( base.float64ToFloat32( 3.14e-34 ) )\ns = base.significandf( base.float64ToFloat32( -3.14 ) )\ns = base.significandf( 0.0 )\ns = base.significandf( NaN )\n",
- "base.signum": "sign = base.signum( -5.0 )\nsign = base.signum( 5.0 )\nsign = base.signum( -0.0 )\nsign = base.signum( 0.0 )\nsign = base.signum( NaN )\n",
- "base.sin": "y = base.sin( 0.0 )\ny = base.sin( PI/2.0 )\ny = base.sin( -PI/6.0 )\ny = base.sin( NaN )\n",
- "base.sinc": "y = base.sinc( 0.5 )\ny = base.sinc( -1.2 )\ny = base.sinc( 0.0 )\ny = base.sinc( NaN )\n",
- "base.sincos": "y = base.sincos( 0.0 )\ny = base.sincos( PI/2.0 )\ny = base.sincos( -PI/6.0 )\ny = base.sincos( NaN )\nout = new Float64Array( 2 );\nv = base.sincos( out, 0.0 )\nbool = ( v === out )\n",
- "base.sincospi": "y = base.sincospi( 0.0 )\ny = base.sincospi( 0.5 )\ny = base.sincospi( 0.1 )\ny = base.sincospi( NaN )\nout = new Float64Array( 2 );\nv = base.sincospi( out, 0.0 )\nbool = ( v === out )\n",
- "base.sinh": "y = base.sinh( 0.0 )\ny = base.sinh( 2.0 )\ny = base.sinh( -2.0 )\ny = base.sinh( NaN )\n",
- "base.sinpi": "y = base.sinpi( 0.0 )\ny = base.sinpi( 0.5 )\ny = base.sinpi( 0.9 )\ny = base.sinpi( NaN )\n",
- "base.spence": "y = base.spence( 3.0 )\ny = base.spence( 0.0 )\ny = base.spence( -9.0 )\ny = base.spence( NaN )\n",
- "base.sqrt": "y = base.sqrt( 4.0 )\ny = base.sqrt( 9.0 )\ny = base.sqrt( 0.0 )\ny = base.sqrt( -4.0 )\ny = base.sqrt( NaN )\n",
- "base.sqrt1pm1": "y = base.sqrt1pm1( 3.0 )\ny = base.sqrt1pm1( 0.5 )\ny = base.sqrt1pm1( 0.02 )\ny = base.sqrt1pm1( -0.5 )\ny = base.sqrt1pm1( -1.1 )\ny = base.sqrt1pm1( NaN )\n",
- "base.sumSeries": "\n// Using an ES6 generator function:\nfunction* geometricSeriesGenerator( x ) {\n var exponent = 0;\n while ( true ) {\n yield Math.pow( x, exponent );\n exponent += 1;\n }\n};\ngen = geometricSeriesGenerator( 0.9 );\nout = base.sumSeries( gen )\n\n// Using a closure:\nfunction geometricSeriesClosure( x ) {\n var exponent = -1;\n return function() {\n exponent += 1;\n return Math.pow( x, exponent );\n };\n};\ngen = geometricSeriesClosure( 0.9 );\nout = base.sumSeries( gen )\n\n// Setting an initial value for the sum:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'initialValue': 1 } )\n\n// Changing the maximum number of terms to be summed:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'maxTerms': 10 } )\n\n// Adjusting the used tolerance:\nout = base.sumSeries( geometricSeriesGenerator( 0.5 ), { 'tolerance': 1e-3 } )\n",
- "base.tan": "y = base.tan( 0.0 )\ny = base.tan( -PI/4.0 )\ny = base.tan( PI/4.0 )\ny = base.tan( NaN )\n",
- "base.tanh": "y = base.tanh( 0.0 )\ny = base.tanh( -0.0 )\ny = base.tanh( 2.0 )\ny = base.tanh( -2.0 )\ny = base.tanh( NaN )\n",
- "base.toBinaryString": "str = base.toBinaryString( 4.0 )\nstr = base.toBinaryString( PI )\nstr = base.toBinaryString( -1.0e308 )\nstr = base.toBinaryString( -3.14e-320 )\nstr = base.toBinaryString( 5.0e-324 )\nstr = base.toBinaryString( 0.0 )\nstr = base.toBinaryString( -0.0 )\nstr = base.toBinaryString( NaN )\nstr = base.toBinaryString( PINF )\nstr = base.toBinaryString( NINF )\n",
- "base.toBinaryStringf": "str = base.toBinaryStringf( base.float64ToFloat32( 4.0 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( PI ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -1.0e38 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( -3.14e-39 ) )\nstr = base.toBinaryStringf( base.float64ToFloat32( 1.4e-45 ) )\nstr = base.toBinaryStringf( 0.0 )\nstr = base.toBinaryStringf( -0.0 )\nstr = base.toBinaryStringf( NaN )\nstr = base.toBinaryStringf( FLOAT32_PINF )\nstr = base.toBinaryStringf( FLOAT32_NINF )\n",
- "base.toBinaryStringUint8": "a = new Uint8Array( [ 1, 4, 9 ] );\nstr = base.toBinaryStringUint8( a[ 0 ] )\nstr = base.toBinaryStringUint8( a[ 1 ] )\nstr = base.toBinaryStringUint8( a[ 2 ] )\n",
- "base.toBinaryStringUint16": "a = new Uint16Array( [ 1, 4, 9 ] );\nstr = base.toBinaryStringUint16( a[ 0 ] )\nstr = base.toBinaryStringUint16( a[ 1 ] )\nstr = base.toBinaryStringUint16( a[ 2 ] )\n",
- "base.toBinaryStringUint32": "a = new Uint32Array( [ 1, 4, 9 ] );\nstr = base.toBinaryStringUint32( a[ 0 ] )\nstr = base.toBinaryStringUint32( a[ 1 ] )\nstr = base.toBinaryStringUint32( a[ 2 ] )\n",
- "base.toWordf": "f32 = base.float64ToFloat32( 1.337 )\nw = base.toWordf( f32 )\n",
- "base.toWords": "w = base.toWords( 3.14e201 )\n\n// Provide an output array:\nout = new Uint32Array( 2 );\nw = base.toWords( out, 3.14e201 )\nbool = ( w === out )\n",
- "base.trigamma": "y = base.trigamma( -2.5 )\ny = base.trigamma( 1.0 )\ny = base.trigamma( 10.0 )\ny = base.trigamma( NaN )\ny = base.trigamma( -1.0 )\n",
- "base.trunc": "y = base.trunc( 3.14 )\ny = base.trunc( -4.2 )\ny = base.trunc( -4.6 )\ny = base.trunc( 9.5 )\ny = base.trunc( -0.0 )\n",
- "base.trunc2": "y = base.trunc2( 3.14 )\ny = base.trunc2( -4.2 )\ny = base.trunc2( -4.6 )\ny = base.trunc2( 9.5 )\ny = base.trunc2( 13.0 )\ny = base.trunc2( -13.0 )\ny = base.trunc2( -0.0 )\n",
- "base.trunc10": "y = base.trunc10( 3.14 )\ny = base.trunc10( -4.2 )\ny = base.trunc10( -4.6 )\ny = base.trunc10( 9.5 )\ny = base.trunc10( 13.0 )\ny = base.trunc10( -13.0 )\ny = base.trunc10( -0.0 )\n",
- "base.truncb": "\n// Round to 4 decimal places:\ny = base.truncb( 3.14159, -4, 10 )\n\n// If `n = 0` or `b = 1`, standard round behavior:\ny = base.truncb( 3.14159, 0, 2 )\n\n// Round to nearest multiple of two toward zero:\ny = base.truncb( 5.0, 1, 2 )\n",
- "base.truncn": "\n// Round to 4 decimal places:\ny = base.truncn( 3.14159, -4 )\n\n// If `n = 0`, standard round behavior:\ny = base.truncn( 3.14159, 0 )\n\n// Round to nearest thousand:\ny = base.truncn( 12368.0, 3 )\n",
- "base.truncsd": "y = base.truncsd( 3.14159, 5 )\ny = base.truncsd( 3.14159, 1 )\ny = base.truncsd( 12368.0, 2 )\ny = base.truncsd( 0.0313, 2, 2 )\n",
- "base.uimul": "v = base.uimul( 10>>>0, 4>>>0 )\n",
- "base.uimuldw": "v = base.uimuldw( 1, 10 )\n",
- "base.uint32ToInt32": "y = base.uint32ToInt32( base.float64ToUint32( 4294967295 ) )\ny = base.uint32ToInt32( base.float64ToUint32( 3 ) )\n",
- "base.vercos": "y = base.vercos( 3.14 )\ny = base.vercos( -4.2 )\ny = base.vercos( -4.6 )\ny = base.vercos( 9.5 )\ny = base.vercos( -0.0 )\n",
- "base.versin": "y = base.versin( 3.14 )\ny = base.versin( -4.2 )\ny = base.versin( -4.6 )\ny = base.versin( 9.5 )\ny = base.versin( -0.0 )\n",
- "base.wrap": "y = base.wrap( 3.14, 0.0, 5.0 )\ny = base.wrap( -3.14, 0.0, 5.0 )\ny = base.wrap( 3.14, 0.0, 3.0 )\ny = base.wrap( -0.0, 0.0, 5.0 )\ny = base.wrap( 0.0, -3.14, -0.0 )\ny = base.wrap( NaN, 0.0, 5.0 )\n",
- "base.xlog1py": "out = base.xlog1py( 3.0, 2.0 )\nout = base.xlog1py( 1.5, 5.9 )\nout = base.xlog1py( 0.9, 1.0 )\nout = base.xlog1py( 1.0, 0.0 )\nout = base.xlog1py( 0.0, -2.0 )\nout = base.xlog1py( 1.5, NaN )\nout = base.xlog1py( 0.0, NaN )\nout = base.xlog1py( NaN, 2.3 )\n",
- "base.xlogy": "out = base.xlogy( 3.0, 2.0 )\nout = base.xlogy( 1.5, 5.9 )\nout = base.xlogy( 0.9, 1.0 )\nout = base.xlogy( 0.0, -2.0 )\nout = base.xlogy( 1.5, NaN )\nout = base.xlogy( 0.0, NaN )\nout = base.xlogy( NaN, 2.3 )\n",
- "base.zeta": "y = base.zeta( 1.1 )\ny = base.zeta( -4.0 )\ny = base.zeta( 70.0 )\ny = base.zeta( 0.5 )\ny = base.zeta( NaN )\n\n// Evaluate at a pole:\ny = base.zeta( 1.0 )\n",
- "BERNDT_CPS_WAGES_1985": "data = BERNDT_CPS_WAGES_1985()\n",
- "bifurcate": "collection = [ 'beep', 'boop', 'foo', 'bar' ];\nf = [ true, true, false, true ];\nout = bifurcate( collection, f )\nf = [ 1, 1, 0, 1 ];\nout = bifurcate( collection, f )\n\n// Output group results as indices:\nf = [ true, true, false, true ];\nopts = { 'returns': 'indices' };\nout = bifurcate( collection, opts, f )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = bifurcate( collection, opts, f )\n",
- "bifurcateBy": "function predicate( v ) { return v[ 0 ] === 'b'; };\ncollection = [ 'beep', 'boop', 'foo', 'bar' ];\nout = bifurcateBy( collection, predicate )\n\n// Output group results as indices:\nopts = { 'returns': 'indices' };\nout = bifurcateBy( collection, opts, predicate )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateBy( collection, opts, predicate )\n",
- "bifurcateByAsync": "\n// Basic usage:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\narr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, predicate, done )\n\n// Output group results as indices:\nopts = { 'returns': 'indices' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\nbifurcateByAsync( arr, opts, predicate, done )\n",
- "bifurcateIn": "function Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nobj = new Foo();\nfunction predicate( v ) { return v[ 0 ] === 'b'; };\nout = bifurcateIn( obj, predicate )\n\n// Output group results as keys:\nopts = { 'returns': 'keys' };\nout = bifurcateIn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateIn( obj, opts, predicate )\n",
- "bifurcateOwn": "function predicate( v ) { return v[ 0 ] === 'b'; };\nobj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nout = bifurcateOwn( obj, predicate )\n\n// Output group results as keys:\nopts = { 'returns': 'keys' };\nout = bifurcateOwn( obj, opts, predicate )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = bifurcateOwn( obj, opts, predicate )\n",
- "binomialTest": "out = binomialTest( 682, 925 )\nout = binomialTest( [ 682, 925 - 682 ] )\nout = binomialTest( 21, 40, {\n 'p': 0.4,\n 'alternative': 'greater'\n})\n",
- "Buffer": "b = new Buffer( 4 )\n",
- "buffer2json": "buf = new allocUnsafe( 2 );\nbuf[ 0 ] = 1;\nbuf[ 1 ] = 2;\njson = buffer2json( buf )\n",
- "capitalize": "out = capitalize( 'beep' )\nout = capitalize( 'Boop' )\n",
- "capitalizeKeys": "obj = { 'aa': 1, 'bb': 2 };\nout = capitalizeKeys( obj )\n",
- "CATALAN": "CATALAN\n",
- "CBRT_EPS": "CBRT_EPS\n",
- "chdir": "err = chdir( '/path/to/current/working/directory' )\n",
- "chi2gof": "\n// Provide expected probabilities...\nx = [ 89, 37, 30, 28, 2 ];\np = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nout = chi2gof( x, p )\nout.print()\n\n// Set significance level...\nopts = { 'alpha': 0.01 };\nout = chi2gof( x, p, opts );\nout.print()\n\n// Calculate the test p-value via Monte Carlo simulation...\nx = [ 89, 37, 30, 28, 2 ];\np = [ 0.40, 0.20, 0.20, 0.15, 0.05 ];\nopts = { 'simulate': true, 'iterations': 1000 };\nout = chi2gof( x, p, opts )\n\n// Verify that data comes from Poisson distribution...\nlambda = 3.0;\nrpois = base.random.poisson.factory( lambda );\nlen = 400;\nx = [];\nfor ( var i = 0; i < len; i++ ) { x.push( rpois() ); };\n\n// Generate a frequency table...\nfreqs = new Int32Array( len );\nfor ( i = 0; i < len; i++ ) { freqs[ x[ i ] ] += 1; };\nout = chi2gof( freqs, 'poisson', lambda )\n",
- "circarray2iterator": "it = circarray2iterator( [ 1, 2, 3, 4 ] );\nv = it.next().value\nv = it.next().value\n",
- "circularArrayStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 15 };\ns = circularArrayStream( [ 1, 2, 3 ], opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "CircularBuffer": "b = CircularBuffer( 3 );\nb.push( 'foo' );\nb.push( 'bar' );\nb.push( 'beep' );\nb.length\nb.count\nb.push( 'boop' )\n",
- "CMUDICT": "data = CMUDICT();\ndict = data.dict\nphones = data.phones\nsymbols = data.symbols\nvp = data.vp\n",
- "complex": "z = complex( 5.0, 3.0, 'float64' )\nz = complex( 5.0, 3.0, 'float32' )\n",
- "Complex64": "z = new Complex64( 5.0, 3.0 )\nz.re\nz.im\n",
- "COMPLEX64_NUM_BYTES": "COMPLEX64_NUM_BYTES\n",
- "Complex128": "z = new Complex128( 5.0, 3.0 )\nz.re\nz.im\n",
- "COMPLEX128_NUM_BYTES": "COMPLEX128_NUM_BYTES\n",
- "compose": "function a( x ) {\n return 2 * x;\n}\nfunction b( x ) {\n return x + 3;\n}\nfunction c( x ) {\n return x / 5;\n}\nf = compose( c, b, a );\nz = f( 6 )\n",
- "composeAsync": "function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nf = composeAsync( c, b, a );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n",
- "configdir": "dir = configdir()\ndir = configdir( 'appname/config' )\n",
- "conj": "z = new Complex128( 5.0, 3.0 );\nz.toString()\nv = conj( z );\nv.toString()\n",
- "constantFunction": "fcn = constantFunction( 3.14 );\nv = fcn()\nv = fcn()\nv = fcn()\n",
- "constantStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = constantStream( 'beep', opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "constructorName": "v = constructorName( 'a' )\nv = constructorName( {} )\nv = constructorName( true )\n",
- "contains": "bool = contains( 'Hello World', 'World' )\nbool = contains( 'Hello World', 'world' )\nbool = contains( [ 1, 2, 3, 4 ], 2 )\nbool = contains( [ NaN, 2, 3, 4 ], NaN )\n\n// Supply a position:\nbool = contains( 'Hello World', 'Hello', 6 )\nbool = contains( [ true, NaN, false ], true, 1 )\n",
- "convertArray": "arr = [ 1.0, 2.0, 3.0, 4.0 ];\nout = convertArray( arr, 'float32' )\n",
- "convertArraySame": "x = [ 1.0, 2.0, 3.0, 4.0 ];\ny = new Float32Array( 0 );\nout = convertArraySame( x, y )\n",
- "convertPath": "out = convertPath( '/c/foo/bar/beep.c', 'win32' )\nout = convertPath( '/c/foo/bar/beep.c', 'mixed' )\nout = convertPath( '/c/foo/bar/beep.c', 'posix' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'win32' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'mixed' )\nout = convertPath( 'C:\\\\\\\\foo\\\\bar\\\\beep.c', 'posix' )\n",
- "copy": "value = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nout = copy( value )\nbool = ( value[ 0 ].c === out[ 0 ].c )\n\n// Set the `level` option to limit the copy depth:\nvalue = [ { 'a': 1, 'b': true, 'c': [ 1, 2, 3 ] } ];\nout = copy( value, 1 );\nbool = ( value[ 0 ] === out[ 0 ] )\nbool = ( value[ 0 ].c === out[ 0 ].c )\n",
- "copyBuffer": "b1 = array2buffer( [ 1, 2, 3, 4 ] );\nb2 = copyBuffer( b1 )\n",
- "countBy": "function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\ncollection = [ 'beep', 'boop', 'foo', 'bar' ];\nout = countBy( collection, indicator )\n",
- "countByAsync": "\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\narr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\ncountByAsync( arr, opts, indicator, done )\n",
- "curry": "function add( x, y ) { return x + y; };\nf = curry( add );\nsum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curry( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nobj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curry( obj.greet, obj );\nstr = f( 'Hello' )( 'there' )\n",
- "curryRight": "function add( x, y ) { return x + y; };\nf = curryRight( add );\nsum = f( 2 )( 3 )\n\n// Supply arity:\nfunction add() { return arguments[ 0 ] + arguments[ 1 ]; };\nf = curryRight( add, 2 );\nsum = f( 2 )( 3 )\n\n// Provide function context:\nobj = {\n 'name': 'Ada',\n 'greet': function greet( word1, word2 ) {\n return word1 + ' ' + word2 + ', ' + this.name + '!'\n }\n};\nf = curryRight( obj.greet, obj );\nstr = f( 'there' )( 'Hello' )\n",
- "cwd": "dir = cwd()\n",
- "DALE_CHALL_NEW": "list = DALE_CHALL_NEW()\n",
- "datasets": "out = datasets( 'MONTH_NAMES_EN' )\nopts = { 'data': 'cities' };\nout = datasets( 'MINARD_NAPOLEONS_MARCH', opts )\n",
- "dayOfQuarter": "day = dayOfQuarter()\nday = dayOfQuarter( new Date() )\nday = dayOfQuarter( 12, 31, 2017 )\n\n// Other ways to supply month:\nday = dayOfQuarter( 'dec', 31, 2017 )\nday = dayOfQuarter( 'december', 31, 2017 )\n",
- "dayOfYear": "day = dayOfYear()\nday = dayOfYear( new Date() )\nday = dayOfYear( 12, 31, 2016 )\n\n// Other ways to supply month:\nday = dayOfYear( 'dec', 31, 2016 )\nday = dayOfYear( 'december', 31, 2016 )\n",
- "daysInMonth": "num = daysInMonth()\nnum = daysInMonth( 2 )\nnum = daysInMonth( 2, 2016 )\nnum = daysInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = daysInMonth( 'feb', 2016 )\nnum = daysInMonth( 'february', 2016 )\n",
- "daysInYear": "num = daysInYear()\nnum = daysInYear( 2016 )\nnum = daysInYear( 2017 )\n",
- "debugSinkStream": "s = debugSinkStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "debugStream": "s = debugStream( { 'name': 'foo' } );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "deepEqual": "bool = deepEqual( [ 1, 2, 3 ], [ 1, 2, 3 ] )\nbool = deepEqual( [ 1, 2, 3 ], [ 1, 2, '3' ] )\nbool = deepEqual( { 'a': 2 }, { 'a': [ 2 ] } )\n",
- "deepGet": "obj = { 'a': { 'b': { 'c': 'd' } } };\nval = deepGet( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nval = deepGet( obj, 'a/b/c', { 'sep': '/' } )\n",
- "deepHasOwnProp": "obj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepHasOwnProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepHasOwnProp( obj, 'a/b/c', { 'sep': '/' } )\n",
- "deepHasProp": "function Foo() { return this; };\nFoo.prototype.b = { 'c': 'd' };\nobj = { 'a': new Foo() };\nbool = deepHasProp( obj, 'a.b.c' )\n\n// Specify a custom separator via the `sep` option:\nbool = deepHasProp( obj, 'a/b/c', { 'sep': '/' } )\n",
- "deepPluck": "arr = [\n { 'a': { 'b': { 'c': 1 } } },\n { 'a': { 'b': { 'c': 2 } } }\n];\nout = deepPluck( arr, 'a.b.c' )\narr = [\n { 'a': [ 0, 1, 2 ] },\n { 'a': [ 3, 4, 5 ] }\n];\nout = deepPluck( arr, [ 'a', 1 ] )\n",
- "deepSet": "obj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepSet( obj, 'a.b.c', 'beep' )\n\n// Specify an alternative separator via the sep option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nbool = deepSet( obj, 'a/b/c', 'beep', { 'sep': '/' } );\nobj\n\n// To create a key path which does not exist, set the create option to true:\nbool = deepSet( obj, 'a.e.c', 'boop', { 'create': true } );\nobj\n",
- "defineProperties": "obj = {};\ndefineProperties( obj, {\n 'foo': {\n 'value': 'bar',\n 'writable': false,\n 'configurable': false,\n 'enumerable': true\n },\n 'baz': {\n 'value': 13\n }\n});\nobj.foo\nobj.baz\n",
- "defineProperty": "obj = {};\ndefineProperty( obj, 'foo', {\n 'value': 'bar',\n 'enumerable': true,\n 'writable': false\n});\nobj.foo = 'boop';\nobj\n",
- "dirname": "dir = dirname( './foo/bar/index.js' )\n",
- "DoublyLinkedList": "list = DoublyLinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n",
- "doUntil": "function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoUntil( beep, predicate )\n",
- "doUntilAsync": "function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoUntilAsync( fcn, predicate, done )\n",
- "doUntilEach": "function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4, NaN, 5 ];\ndoUntilEach( arr, logger, predicate )\n",
- "doUntilEachRight": "function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, NaN, 2, 3, 4, 5 ];\ndoUntilEachRight( arr, logger, predicate )\n",
- "doWhile": "function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\ndoWhile( beep, predicate )\n",
- "doWhileAsync": "function fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ndoWhileAsync( fcn, predicate, done )\n",
- "doWhileEach": "function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4, NaN, 5 ];\ndoWhileEach( arr, logger, predicate )\n",
- "doWhileEachRight": "function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, NaN, 2, 3, 4, 5 ];\ndoWhileEachRight( arr, logger, predicate )\n",
- "E": "E\n",
- "emptyStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\ns = emptyStream();\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "endsWith": "bool = endsWith( 'beep', 'ep' )\nbool = endsWith( 'Beep', 'op' )\nbool = endsWith( 'Beep', 'ee', 3 )\nbool = endsWith( 'Beep', 'ee', -1 )\nbool = endsWith( 'beep', '' )\n",
- "enumerableProperties": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nprops = enumerableProperties( obj )\n",
- "enumerablePropertiesIn": "props = enumerablePropertiesIn( [] )\n",
- "enumerablePropertySymbols": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = enumerablePropertySymbols( obj )\n",
- "enumerablePropertySymbolsIn": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = enumerablePropertySymbolsIn( obj )\n",
- "ENV": "user = ENV.USER\n",
- "EPS": "EPS\n",
- "error2json": "err = new Error( 'beep' );\njson = error2json( err )\n",
- "EULERGAMMA": "EULERGAMMA\n",
- "every": "arr = [ 1, 1, 1, 1, 1 ];\nbool = every( arr )\n",
- "everyBy": "function positive( v ) { return ( v > 0 ); };\narr = [ 1, 2, 3, 4 ];\nbool = everyBy( arr, positive )\n",
- "everyByAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\neveryByAsync( arr, opts, predicate, done )\n",
- "everyByRight": "function positive( v ) { return ( v > 0 ); };\narr = [ 1, 2, 3, 4 ];\nbool = everyByRight( arr, positive )\n",
- "everyByRightAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, true );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\neveryByRightAsync( arr, opts, predicate, done )\n",
- "evil": "v = evil( '5*4*3*2*1' )\n",
- "exists": "function done( error, bool ) { console.log( bool ); };\nexists( './beep/boop', done );\n",
- "expandContractions": "str = 'I won\\'t be able to get y\\'all out of this one.';\nout = expandContractions( str )\nstr = 'It oughtn\\'t to be my fault, because, you know, I didn\\'t know';\nout = expandContractions( str )\n",
- "extname": "ext = extname( 'index.js' )\n",
- "fastmath.abs": "v = fastmath.abs( -1.0 )\nv = fastmath.abs( 2.0 )\nv = fastmath.abs( 0.0 )\nv = fastmath.abs( -0.0 )\nv = fastmath.abs( NaN )\n",
- "fastmath.acosh": "v = fastmath.acosh( 1.0 )\nv = fastmath.acosh( 2.0 )\nv = fastmath.acosh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.acosh( 1.0e308 )\n",
- "fastmath.ampbm": "h = fastmath.ampbm( 5.0, 12.0 )\n",
- "fastmath.asinh": "v = fastmath.asinh( 0.0 )\nv = fastmath.asinh( 2.0 )\nv = fastmath.asinh( -2.0 )\nv = fastmath.asinh( NaN )\n\n// The function overflows for large `x`:\nv = fastmath.asinh( 1.0e200 )\n\n// The function underflows for small `x`:\nv = fastmath.asinh( 1.0e-50 )\n",
- "fastmath.atanh": "v = fastmath.atanh( 0.0 )\nv = fastmath.atanh( 0.9 )\nv = fastmath.atanh( 1.0 )\nv = fastmath.atanh( -1.0 )\nv = fastmath.atanh( NaN )\n\n// The function underflows for small `x`:\nv = fastmath.atanh( 1.0e-17 )\n",
- "fastmath.hypot": "h = fastmath.hypot( -5.0, 12.0 )\n\n// For a sufficiently large `x` and/or `y`, the function overflows:\nh = fastmath.hypot( 1.0e154, 1.0e154 )\n\n// For sufficiently small `x` and/or `y`, the function underflows:\nh = fastmath.hypot( 1e-200, 1.0e-200 )\n",
- "fastmath.log2Uint32": "v = fastmath.log2Uint32( 4 >>> 0 )\nv = fastmath.log2Uint32( 8 >>> 0 )\nv = fastmath.log2Uint32( 9 >>> 0 )\n",
- "fastmath.max": "v = fastmath.max( 3.14, 4.2 )\nv = fastmath.max( 3.14, NaN )\nv = fastmath.max( NaN, 3.14 )\nv = fastmath.max( -0.0, +0.0 )\nv = fastmath.max( +0.0, -0.0 )\n",
- "fastmath.min": "v = fastmath.min( 3.14, 4.2 )\nv = fastmath.min( 3.14, NaN )\nv = fastmath.min( NaN, 3.14 )\nv = fastmath.min( -0.0, +0.0 )\nv = fastmath.min( +0.0, -0.0 )\n",
- "fastmath.powint": "v = fastmath.powint( 2.0, 3 )\nv = fastmath.powint( 3.14, 0 )\nv = fastmath.powint( 2.0, -2 )\nv = fastmath.powint( 0.0, 0 )\nv = fastmath.powint( -3.14, 1 )\nv = fastmath.powint( NaN, 0 )\n",
- "fastmath.sqrtUint32": "v = fastmath.sqrtUint32( 9 >>> 0 )\nv = fastmath.sqrtUint32( 2 >>> 0 )\nv = fastmath.sqrtUint32( 3 >>> 0 )\nv = fastmath.sqrtUint32( 0 >>> 0 )\n",
- "FEMALE_FIRST_NAMES_EN": "list = FEMALE_FIRST_NAMES_EN()\n",
- "FIFO": "q = FIFO();\nq.push( 'foo' ).push( 'bar' );\nq.length\nq.pop()\nq.length\nq.pop()\nq.length\n",
- "find": "data = [ 30, 20, 50, 60, 10 ];\nfunction condition( val ) { return val > 20; };\nvals = find( data, condition )\n\n// Limit number of results:\ndata = [ 30, 20, 50, 60, 10 ];\nopts = { 'k': 2, 'returns': 'values' };\nvals = find( data, opts, condition )\n\n// Return both indices and values as index-value pairs:\ndata = [ 30, 20, 50, 60, 10 ];\nopts = { 'k': -2, 'returns': '*' };\nvals = find( data, opts, condition )\n",
- "flattenArray": "arr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr )\n\n// Set the maximum depth:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2 } )\nbool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n\n// Deep copy:\narr = [ 1, [ 2, [ 3, [ 4, [ 5 ], 6 ], 7 ], 8 ], 9 ];\nout = flattenArray( arr, { 'depth': 2, 'copy': true } )\nbool = ( arr[ 1 ][ 1 ][ 1 ] === out[ 3 ] )\n",
- "flattenObject": "obj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj )\n\n// Set the `depth` option to flatten to a specified depth:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'depth': 1 } )\nbool = ( obj.a.b === out[ 'a.b' ] )\n\n// Set the `delimiter` option:\nobj = { 'a': { 'b': { 'c': 'd' } } };\nout = flattenObject( obj, { 'delimiter': '-|-' } )\n\n// Flatten arrays:\nobj = { 'a': { 'b': [ 1, 2, 3 ] } };\nout = flattenObject( obj, { 'flattenArrays': true } )\n",
- "flignerTest": "\n// Data from Hollander & Wolfe (1973), p. 116:\nx = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\ny = [ 3.8, 2.7, 4.0, 2.4 ];\nz = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nout = flignerTest( x, y, z )\narr = [ 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];\ngroups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = flignerTest( arr, { 'groups': groups })\n",
- "FLOAT16_CBRT_EPS": "FLOAT16_CBRT_EPS\n",
- "FLOAT16_EPS": "FLOAT16_EPS\n",
- "FLOAT16_EXPONENT_BIAS": "FLOAT16_EXPONENT_BIAS\n",
- "FLOAT16_MAX": "FLOAT16_MAX\n",
- "FLOAT16_MAX_SAFE_INTEGER": "FLOAT16_MAX_SAFE_INTEGER\n",
- "FLOAT16_MIN_SAFE_INTEGER": "FLOAT16_MIN_SAFE_INTEGER\n",
- "FLOAT16_NINF": "FLOAT16_NINF\n",
- "FLOAT16_NUM_BYTES": "FLOAT16_NUM_BYTES\n",
- "FLOAT16_PINF": "FLOAT16_PINF\n",
- "FLOAT16_PRECISION": "FLOAT16_PRECISION\n",
- "FLOAT16_SMALLEST_NORMAL": "FLOAT16_SMALLEST_NORMAL\n",
- "FLOAT16_SMALLEST_SUBNORMAL": "FLOAT16_SMALLEST_SUBNORMAL\n",
- "FLOAT16_SQRT_EPS": "FLOAT16_SQRT_EPS\n",
- "FLOAT32_CBRT_EPS": "FLOAT32_CBRT_EPS\n",
- "FLOAT32_EPS": "FLOAT32_EPS\n",
- "FLOAT32_EXPONENT_BIAS": "FLOAT32_EXPONENT_BIAS\n",
- "FLOAT32_MAX": "FLOAT32_MAX\n",
- "FLOAT32_MAX_SAFE_INTEGER": "FLOAT32_MAX_SAFE_INTEGER\n",
- "FLOAT32_MIN_SAFE_INTEGER": "FLOAT32_MIN_SAFE_INTEGER\n",
- "FLOAT32_NINF": "FLOAT32_NINF\n",
- "FLOAT32_NUM_BYTES": "FLOAT32_NUM_BYTES\n",
- "FLOAT32_PINF": "FLOAT32_PINF\n",
- "FLOAT32_PRECISION": "FLOAT32_PRECISION\n",
- "FLOAT32_SMALLEST_NORMAL": "FLOAT32_SMALLEST_NORMAL\n",
- "FLOAT32_SMALLEST_SUBNORMAL": "FLOAT32_SMALLEST_SUBNORMAL\n",
- "FLOAT32_SQRT_EPS": "FLOAT32_SQRT_EPS\n",
- "Float32Array": "arr = new Float32Array()\n",
- "FLOAT64_EXPONENT_BIAS": "FLOAT64_EXPONENT_BIAS\n",
- "FLOAT64_HIGH_WORD_EXPONENT_MASK": "FLOAT64_HIGH_WORD_EXPONENT_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_EXPONENT_MASK )\n",
- "FLOAT64_HIGH_WORD_SIGNIFICAND_MASK": "FLOAT64_HIGH_WORD_SIGNIFICAND_MASK\nbase.toBinaryStringUint32( FLOAT64_HIGH_WORD_SIGNIFICAND_MASK )\n",
- "FLOAT64_MAX": "FLOAT64_MAX\n",
- "FLOAT64_MAX_BASE2_EXPONENT": "FLOAT64_MAX_BASE2_EXPONENT\n",
- "FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL": "FLOAT64_MAX_BASE2_EXPONENT_SUBNORMAL\n",
- "FLOAT64_MAX_BASE10_EXPONENT": "FLOAT64_MAX_BASE10_EXPONENT\n",
- "FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL": "FLOAT64_MAX_BASE10_EXPONENT_SUBNORMAL\n",
- "FLOAT64_MAX_LN": "FLOAT64_MAX_LN\n",
- "FLOAT64_MAX_SAFE_FIBONACCI": "FLOAT64_MAX_SAFE_FIBONACCI\n",
- "FLOAT64_MAX_SAFE_INTEGER": "FLOAT64_MAX_SAFE_INTEGER\n",
- "FLOAT64_MAX_SAFE_LUCAS": "FLOAT64_MAX_SAFE_LUCAS\n",
- "FLOAT64_MAX_SAFE_NTH_FIBONACCI": "FLOAT64_MAX_SAFE_NTH_FIBONACCI\n",
- "FLOAT64_MAX_SAFE_NTH_LUCAS": "FLOAT64_MAX_SAFE_NTH_LUCAS\n",
- "FLOAT64_MIN_BASE2_EXPONENT": "FLOAT64_MIN_BASE2_EXPONENT\n",
- "FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL": "FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL\n",
- "FLOAT64_MIN_BASE10_EXPONENT": "FLOAT64_MIN_BASE10_EXPONENT\n",
- "FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL": "FLOAT64_MIN_BASE10_EXPONENT_SUBNORMAL\n",
- "FLOAT64_MIN_LN": "FLOAT64_MIN_LN\n",
- "FLOAT64_MIN_SAFE_INTEGER": "FLOAT64_MIN_SAFE_INTEGER\n",
- "FLOAT64_NUM_BYTES": "FLOAT64_NUM_BYTES\n",
- "FLOAT64_PRECISION": "FLOAT64_PRECISION\n",
- "FLOAT64_SMALLEST_NORMAL": "FLOAT64_SMALLEST_NORMAL\n",
- "FLOAT64_SMALLEST_SUBNORMAL": "FLOAT64_SMALLEST_SUBNORMAL\n",
- "Float64Array": "arr = new Float64Array()\n",
- "forEach": "function logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4 ];\nforEach( arr, logger )\n",
- "forEachAsync": "\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\narr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\nforEachAsync( arr, opts, onDuration, done )\n",
- "forEachRight": "function logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4 ];\nforEachRight( arr, logger )\n",
- "forEachRightAsync": "\n// Basic usage:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\narr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, onDuration, done )\n\n// Limit number of concurrent invocations:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n\n// Process sequentially:\nfunction onDuration( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next();\n }\n};\nfunction done( error ) {\n if ( error ) {\n throw error;\n }\n console.log( 'Done.' );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\nforEachRightAsync( arr, opts, onDuration, done )\n",
- "forIn": "function logger( v, k ) { console.log( '%s: %d', k, v ); };\nfunction Foo() { return this; };\nFoo.prototype.beep = 'boop';\nobj = new Foo();\nforIn( obj, logger )\n",
- "forOwn": "function logger( v, k ) { console.log( '%s: %d', k, v ); };\nobj = { 'a': 1, 'b': 2, 'c': 3, 'd': 4 };\nforOwn( obj, logger )\n",
- "FOURTH_PI": "FOURTH_PI\n",
- "FOURTH_ROOT_EPS": "FOURTH_ROOT_EPS\n",
- "FRB_SF_WAGE_RIGIDITY": "data = FRB_SF_WAGE_RIGIDITY()\n",
- "fromCodePoint": "out = fromCodePoint( 9731 )\nout = fromCodePoint( [ 9731 ] )\nout = fromCodePoint( 97, 98, 99 )\nout = fromCodePoint( [ 97, 98, 99 ] )\n",
- "functionName": "v = functionName( String )\nv = functionName( function foo(){} )\nv = functionName( function(){} )\n",
- "functionSequence": "function a( x ) { return 2 * x; };\nfunction b( x ) { return x + 3; };\nfunction c( x ) { return x / 5; };\nf = functionSequence( a, b, c );\nz = f( 6 )\n",
- "functionSequenceAsync": "function a( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, 2*x );\n }\n};\nfunction b( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x+3 );\n }\n};\nfunction c( x, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, x/5 );\n }\n};\nf = functionSequenceAsync( a, b, c );\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nf( 6, done )\n",
- "GAMMA_LANCZOS_G": "GAMMA_LANCZOS_G\n",
- "getegid": "gid = getegid()\n",
- "geteuid": "uid = geteuid()\n",
- "getgid": "gid = getgid()\n",
- "getGlobal": "g = getGlobal()\n",
- "getPrototypeOf": "proto = getPrototypeOf( {} )\n",
- "getuid": "uid = getuid()\n",
- "GLAISHER": "GLAISHER\n",
- "group": "collection = [ 'beep', 'boop', 'foo', 'bar' ];\ngroups = [ 'b', 'b', 'f', 'b' ];\nout = group( collection, groups )\ngroups = [ 1, 1, 2, 1 ];\nout = group( collection, groups )\n\n// Output group results as indices:\ngroups = [ 'b', 'b', 'f', 'b' ];\nopts = { 'returns': 'indices' };\nout = group( collection, opts, groups )\n\n// Output group results as index-element pairs:\nopts = { 'returns': '*' };\nout = group( collection, opts, groups )\n",
- "groupBy": "function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\ncollection = [ 'beep', 'boop', 'foo', 'bar' ];\nout = groupBy( collection, indicator )\n\n// Output group results as indices:\nopts = { 'returns': 'indices' };\nout = groupBy( collection, opts, indicator )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\nout = groupBy( collection, opts, indicator )\n",
- "groupByAsync": "\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\narr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, indicator, done )\n\n// Output group results as indices:\nopts = { 'returns': 'indices' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Output group results as index-value pairs:\nopts = { 'returns': '*' };\ngroupByAsync( arr, opts, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\ngroupByAsync( arr, opts, indicator, done )\n",
- "groupIn": "function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nfunction Foo() { this.a = 'beep'; this.b = 'boop'; return this; };\nFoo.prototype = Object.create( null );\nFoo.prototype.c = 'foo';\nFoo.prototype.d = 'bar';\nobj = new Foo();\nout = groupIn( obj, indicator )\n\n// Output group results as keys:\nopts = { 'returns': 'keys' };\nout = groupIn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupIn( obj, opts, indicator )\n",
- "groupOwn": "function indicator( v ) {\n if ( v[ 0 ] === 'b' ) {\n return 'b';\n }\n return 'other';\n};\nobj = { 'a': 'beep', 'b': 'boop', 'c': 'foo', 'd': 'bar' };\nout = groupOwn( obj, indicator )\n\n// Output group results as keys:\nopts = { 'returns': 'keys' };\nout = groupOwn( obj, opts, indicator )\n\n// Output group results as key-value pairs:\nopts = { 'returns': '*' };\nout = groupOwn( obj, opts, indicator )\n",
- "HALF_LN2": "HALF_LN2\n",
- "HALF_PI": "HALF_PI\n",
- "HARRISON_BOSTON_HOUSE_PRICES": "data = HARRISON_BOSTON_HOUSE_PRICES()\n",
- "HARRISON_BOSTON_HOUSE_PRICES_CORRECTED": "data = HARRISON_BOSTON_HOUSE_PRICES_CORRECTED()\n",
- "hasArrayBufferSupport": "bool = hasArrayBufferSupport()\n",
- "hasAsyncAwaitSupport": "bool = hasAsyncAwaitSupport()\n",
- "hasAsyncIteratorSymbolSupport": "bool = hasAsyncIteratorSymbolSupport()\n",
- "hasClassSupport": "bool = hasClassSupport()\n",
- "hasDefinePropertiesSupport": "bool = hasDefinePropertiesSupport()\n",
- "hasDefinePropertySupport": "bool = hasDefinePropertySupport()\n",
- "hasFloat32ArraySupport": "bool = hasFloat32ArraySupport()\n",
- "hasFloat64ArraySupport": "bool = hasFloat64ArraySupport()\n",
- "hasFunctionNameSupport": "bool = hasFunctionNameSupport()\n",
- "hasGeneratorSupport": "bool = hasGeneratorSupport()\n",
- "hasInt8ArraySupport": "bool = hasInt8ArraySupport()\n",
- "hasInt16ArraySupport": "bool = hasInt16ArraySupport()\n",
- "hasInt32ArraySupport": "bool = hasInt32ArraySupport()\n",
- "hasIteratorSymbolSupport": "bool = hasIteratorSymbolSupport()\n",
- "hasMapSupport": "bool = hasMapSupport()\n",
- "hasNodeBufferSupport": "bool = hasNodeBufferSupport()\n",
- "hasOwnProp": "beep = { 'boop': true };\nbool = hasOwnProp( beep, 'boop' )\nbool = hasOwnProp( beep, 'bop' )\n",
- "hasProp": "beep = { 'boop': true };\nbool = hasProp( beep, 'boop' )\nbool = hasProp( beep, 'toString' )\nbool = hasProp( beep, 'bop' )\n",
- "hasProxySupport": "bool = hasProxySupport()\n",
- "hasSetSupport": "bool = hasSetSupport()\n",
- "hasSharedArrayBufferSupport": "bool = hasSharedArrayBufferSupport()\n",
- "hasSymbolSupport": "bool = hasSymbolSupport()\n",
- "hasToStringTagSupport": "bool = hasToStringTagSupport()\n",
- "hasUint8ArraySupport": "bool = hasUint8ArraySupport()\n",
- "hasUint8ClampedArraySupport": "bool = hasUint8ClampedArraySupport()\n",
- "hasUint16ArraySupport": "bool = hasUint16ArraySupport()\n",
- "hasUint32ArraySupport": "bool = hasUint32ArraySupport()\n",
- "hasWeakMapSupport": "bool = hasWeakMapSupport()\n",
- "hasWeakSetSupport": "bool = hasWeakSetSupport()\n",
- "hasWebAssemblySupport": "bool = hasWebAssemblySupport()\n",
- "HERNDON_VENUS_SEMIDIAMETERS": "d = HERNDON_VENUS_SEMIDIAMETERS()\n",
- "homedir": "home = homedir()\n",
- "HOURS_IN_DAY": "days = 3.14;\nhrs = days * HOURS_IN_DAY\n",
- "HOURS_IN_WEEK": "wks = 3.14;\nhrs = wks * HOURS_IN_WEEK\n",
- "hoursInMonth": "num = hoursInMonth()\nnum = hoursInMonth( 2 )\nnum = hoursInMonth( 2, 2016 )\nnum = hoursInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = hoursInMonth( 'feb', 2016 )\nnum = hoursInMonth( 'february', 2016 )\n",
- "hoursInYear": "num = hoursInYear()\nnum = hoursInYear( 2016 )\nnum = hoursInYear( 2017 )\n",
- "httpServer": "\n// Basic usage:\ncreateServer = httpServer()\n\n// Provide a request callback:\nfunction onRequest( request, response ) {\n console.log( request.url );\n response.end( 'OK' );\n};\ncreateServer = httpServer( onRequest )\n\n// Specify a specific port:\nopts = { 'port': 7331 };\ncreateServer = httpServer( opts )\n",
- "identity": "v = identity( 3.14 )\n",
- "ifelse": "z = ifelse( true, 1.0, -1.0 )\nz = ifelse( false, 1.0, -1.0 )\n",
- "ifelseAsync": "function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, true );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifelseAsync( predicate, 'beep', 'boop', done )\n",
- "ifthen": "function x() { return 1.0; };\nfunction y() { return -1.0; };\nz = ifthen( true, x, y )\nz = ifthen( false, x, y )\n",
- "ifthenAsync": "function predicate( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, false );\n }\n};\nfunction x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'beep' );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nifthenAsync( predicate, x, y, done )\n",
- "imag": "z = new Complex128( 5.0, 3.0 );\nim = imag( z )\n",
- "IMG_ACANTHUS_MOLLIS": "img = IMG_ACANTHUS_MOLLIS()\n",
- "IMG_AIRPLANE_FROM_ABOVE": "img = IMG_AIRPLANE_FROM_ABOVE()\n",
- "IMG_ALLIUM_OREOPHILUM": "img = IMG_ALLIUM_OREOPHILUM()\n",
- "IMG_BLACK_CANYON": "img = IMG_BLACK_CANYON()\n",
- "IMG_DUST_BOWL_HOME": "img = IMG_DUST_BOWL_HOME()\n",
- "IMG_FRENCH_ALPINE_LANDSCAPE": "img = IMG_FRENCH_ALPINE_LANDSCAPE()\n",
- "IMG_LOCOMOTION_HOUSE_CAT": "img = IMG_LOCOMOTION_HOUSE_CAT()\n",
- "IMG_LOCOMOTION_NUDE_MALE": "img = IMG_LOCOMOTION_NUDE_MALE()\n",
- "IMG_MARCH_PASTORAL": "img = IMG_MARCH_PASTORAL()\n",
- "IMG_NAGASAKI_BOATS": "img = IMG_NAGASAKI_BOATS()\n",
- "incrapcorr": "accumulator = incrapcorr();\nar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator()\n",
- "incrcount": "accumulator = incrcount();\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n",
- "incrcovariance": "accumulator = incrcovariance();\nv = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator()\n",
- "incrcovmat": "accumulator = incrcovmat( 2 );\nout = accumulator()\nvec = ndarray( 'float64', 1 );\nbuf = new Float64Array( 2 );\nshape = [ 2 ];\nstrides = [ 1 ];\nv = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n",
- "incrcv": "accumulator = incrcv();\ncv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator()\n",
- "increwmean": "accumulator = increwmean( 0.5 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n",
- "increwstdev": "accumulator = increwstdev( 0.5 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "increwvariance": "accumulator = increwvariance( 0.5 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n",
- "incrgmean": "accumulator = incrgmean();\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrgrubbs": "acc = incrgrubbs();\nres = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n",
- "incrhmean": "accumulator = incrhmean();\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrkmeans": "accumulator = incrkmeans( 5, 2 );\nvec = ndarray( 'float64', 1 );\nbuf = new Float64Array( 2 );\nshape = [ 2 ];\nstrides = [ 1 ];\nv = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v );\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v );\n",
- "incrkurtosis": "accumulator = incrkurtosis();\nv = accumulator( 2.0 )\nv = accumulator( 2.0 )\nv = accumulator( -4.0 )\nv = accumulator( -4.0 )\n",
- "incrmaape": "accumulator = incrmaape();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n",
- "incrmae": "accumulator = incrmae();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n",
- "incrmapcorr": "accumulator = incrmapcorr( 3 );\nar = accumulator()\nar = accumulator( 2.0, 1.0 )\nar = accumulator( -5.0, 3.14 )\nar = accumulator( 3.0, -1.0 )\nar = accumulator( 5.0, -9.5 )\nar = accumulator()\n",
- "incrmape": "accumulator = incrmape();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n",
- "incrmax": "accumulator = incrmax();\nm = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n",
- "incrmaxabs": "accumulator = incrmaxabs();\nm = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n",
- "incrmcovariance": "accumulator = incrmcovariance( 3 );\nv = accumulator()\nv = accumulator( 2.0, 1.0 )\nv = accumulator( -5.0, 3.14 )\nv = accumulator( 3.0, -1.0 )\nv = accumulator( 5.0, -9.5 )\nv = accumulator()\n",
- "incrmcv": "accumulator = incrmcv( 3 );\ncv = accumulator()\ncv = accumulator( 2.0 )\ncv = accumulator( 1.0 )\ncv = accumulator( 3.0 )\ncv = accumulator( 7.0 )\ncv = accumulator()\n",
- "incrmda": "accumulator = incrmda();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 4.0 )\nm = accumulator()\n",
- "incrme": "accumulator = incrme();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n",
- "incrmean": "accumulator = incrmean();\nmu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n",
- "incrmeanabs": "accumulator = incrmeanabs();\nmu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n",
- "incrmeanabs2": "accumulator = incrmeanabs2();\nmu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator()\n",
- "incrmeanstdev": "accumulator = incrmeanstdev();\nms = accumulator()\nms = accumulator( 2.0 )\nms = accumulator( -5.0 )\nms = accumulator( 3.0 )\nms = accumulator( 5.0 )\nms = accumulator()\n",
- "incrmeanvar": "accumulator = incrmeanvar();\nmv = accumulator()\nmv = accumulator( 2.0 )\nmv = accumulator( -5.0 )\nmv = accumulator( 3.0 )\nmv = accumulator( 5.0 )\nmv = accumulator()\n",
- "incrmgmean": "accumulator = incrmgmean( 3 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrmgrubbs": "acc = incrmgrubbs( 20 );\nres = acc()\nfor ( var i = 0; i < 200; i++ ) {\n res = acc( base.random.normal( 10.0, 5.0 ) );\n};\nres.print()\n",
- "incrmhmean": "accumulator = incrmhmean( 3 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( 5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrmidrange": "accumulator = incrmidrange();\nv = accumulator()\nv = accumulator( 3.14 )\nv = accumulator( -5.0 )\nv = accumulator( 10.1 )\nv = accumulator()\n",
- "incrmin": "accumulator = incrmin();\nm = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n",
- "incrminabs": "accumulator = incrminabs();\nm = accumulator()\nm = accumulator( 3.14 )\nm = accumulator( -5.0 )\nm = accumulator( 10.1 )\nm = accumulator()\n",
- "incrminmax": "accumulator = incrminmax();\nmm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n",
- "incrminmaxabs": "accumulator = incrminmaxabs();\nmm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n",
- "incrmmaape": "accumulator = incrmmaape( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n",
- "incrmmae": "accumulator = incrmmae( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n",
- "incrmmape": "accumulator = incrmmape( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n",
- "incrmmax": "accumulator = incrmmax( 3 );\nm = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n",
- "incrmmaxabs": "accumulator = incrmmaxabs( 3 );\nm = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n",
- "incrmmda": "accumulator = incrmmda( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 4.0, 5.0 )\nm = accumulator()\n",
- "incrmme": "accumulator = incrmme( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n",
- "incrmmean": "accumulator = incrmmean( 3 );\nmu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n",
- "incrmmeanabs": "accumulator = incrmmeanabs( 3 );\nmu = accumulator()\nmu = accumulator( 2.0 )\nmu = accumulator( -5.0 )\nmu = accumulator( 3.0 )\nmu = accumulator( 5.0 )\nmu = accumulator()\n",
- "incrmmeanabs2": "accumulator = incrmmeanabs2( 3 );\nm = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n",
- "incrmmeanstdev": "accumulator = incrmmeanstdev( 3 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrmmeanvar": "accumulator = incrmmeanvar( 3 );\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( 3.0 )\nv = accumulator( 5.0 )\nv = accumulator()\n",
- "incrmmidrange": "accumulator = incrmmidrange( 3 );\nmr = accumulator()\nmr = accumulator( 2.0 )\nmr = accumulator( -5.0 )\nmr = accumulator( 3.0 )\nmr = accumulator( 5.0 )\nmr = accumulator()\n",
- "incrmmin": "accumulator = incrmmin( 3 );\nm = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n",
- "incrmminabs": "accumulator = incrmminabs( 3 );\nm = accumulator()\nm = accumulator( 2.0 )\nm = accumulator( -5.0 )\nm = accumulator( 3.0 )\nm = accumulator( 5.0 )\nm = accumulator()\n",
- "incrmminmax": "accumulator = incrmminmax( 3 );\nmm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n",
- "incrmminmaxabs": "accumulator = incrmminmaxabs( 3 );\nmm = accumulator()\nmm = accumulator( 2.0 )\nmm = accumulator( -5.0 )\nmm = accumulator( 3.0 )\nmm = accumulator( 5.0 )\nmm = accumulator()\n",
- "incrmmpe": "accumulator = incrmmpe( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 2.0, 5.0 )\nm = accumulator()\n",
- "incrmmse": "accumulator = incrmmse( 3 );\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator( 3.0, 2.0 )\nm = accumulator( 5.0, -2.0 )\nm = accumulator()\n",
- "incrmpcorr": "accumulator = incrmpcorr( 3 );\nr = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator( 3.0, -1.0 )\nr = accumulator( 5.0, -9.5 )\nr = accumulator()\n",
- "incrmpcorr2": "accumulator = incrmpcorr2( 3 );\nr2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator( 3.0, -1.0 )\nr2 = accumulator( 5.0, -9.5 )\nr2 = accumulator()\n",
- "incrmpcorrdist": "accumulator = incrmpcorrdist( 3 );\nd = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator( 3.0, -1.0 )\nd = accumulator( 5.0, -9.5 )\nd = accumulator()\n",
- "incrmpe": "accumulator = incrmpe();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( 5.0, 2.0 )\nm = accumulator()\n",
- "incrmprod": "accumulator = incrmprod( 3 );\np = accumulator()\np = accumulator( 2.0 )\np = accumulator( -5.0 )\np = accumulator( 3.0 )\np = accumulator( 5.0 )\np = accumulator()\n",
- "incrmrange": "accumulator = incrmrange( 3 );\nr = accumulator()\nr = accumulator( 2.0 )\nr = accumulator( -5.0 )\nr = accumulator( 3.0 )\nr = accumulator( 5.0 )\nr = accumulator()\n",
- "incrmrmse": "accumulator = incrmrmse( 3 );\nr = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n",
- "incrmrss": "accumulator = incrmrss( 3 );\nr = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator( 3.0, 2.0 )\nr = accumulator( 5.0, -2.0 )\nr = accumulator()\n",
- "incrmse": "accumulator = incrmse();\nm = accumulator()\nm = accumulator( 2.0, 3.0 )\nm = accumulator( -5.0, 2.0 )\nm = accumulator()\n",
- "incrmstdev": "accumulator = incrmstdev( 3 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n",
- "incrmsum": "accumulator = incrmsum( 3 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( 5.0 )\ns = accumulator()\n",
- "incrmsumabs": "accumulator = incrmsumabs( 3 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrmsumabs2": "accumulator = incrmsumabs2( 3 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator( 3.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrmsummary": "accumulator = incrmsummary( 3 );\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrmsumprod": "accumulator = incrmsumprod( 3 );\ns = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator( 3.0, -2.0 )\ns = accumulator( 5.0, 3.0 )\ns = accumulator()\n",
- "incrmvariance": "accumulator = incrmvariance( 3 );\ns2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator( 3.0 )\ns2 = accumulator( 5.0 )\ns2 = accumulator()\n",
- "incrmvmr": "accumulator = incrmvmr( 3 );\nF = accumulator()\nF = accumulator( 2.0 )\nF = accumulator( 1.0 )\nF = accumulator( 3.0 )\nF = accumulator( 7.0 )\nF = accumulator()\n",
- "incrpcorr": "accumulator = incrpcorr();\nr = accumulator()\nr = accumulator( 2.0, 1.0 )\nr = accumulator( -5.0, 3.14 )\nr = accumulator()\n",
- "incrpcorr2": "accumulator = incrpcorr2();\nr2 = accumulator()\nr2 = accumulator( 2.0, 1.0 )\nr2 = accumulator( -5.0, 3.14 )\nr2 = accumulator()\n",
- "incrpcorrdist": "accumulator = incrpcorrdist();\nd = accumulator()\nd = accumulator( 2.0, 1.0 )\nd = accumulator( -5.0, 3.14 )\nd = accumulator()\n",
- "incrpcorrdistmat": "accumulator = incrpcorrdistmat( 2 );\nout = accumulator()\nvec = ndarray( 'float64', 1 );\nbuf = new Float64Array( 2 );\nshape = [ 2 ];\nstrides = [ 1 ];\nv = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n",
- "incrpcorrmat": "accumulator = incrpcorrmat( 2 );\nout = accumulator()\nvec = ndarray( 'float64', 1 );\nbuf = new Float64Array( 2 );\nshape = [ 2 ];\nstrides = [ 1 ];\nv = vec( buf, shape, strides, 0, 'row-major' );\nv.set( 0, 2.0 );\nv.set( 1, 1.0 );\nout = accumulator( v )\nv.set( 0, -5.0 );\nv.set( 1, 3.14 );\nout = accumulator( v )\nout = accumulator()\n",
- "incrprod": "accumulator = incrprod();\nv = accumulator()\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator()\n",
- "incrrange": "accumulator = incrrange();\nv = accumulator()\nv = accumulator( -2.0 )\nv = accumulator( 1.0 )\nv = accumulator( 3.0 )\nv = accumulator()\n",
- "incrrmse": "accumulator = incrrmse();\nr = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n",
- "incrrss": "accumulator = incrrss();\nr = accumulator()\nr = accumulator( 2.0, 3.0 )\nr = accumulator( -5.0, 2.0 )\nr = accumulator()\n",
- "incrskewness": "accumulator = incrskewness();\nv = accumulator( 2.0 )\nv = accumulator( -5.0 )\nv = accumulator( -10.0 )\nv = accumulator()\n",
- "incrspace": "arr = incrspace( 0, 11, 2 )\n",
- "incrstdev": "accumulator = incrstdev();\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrsum": "accumulator = incrsum();\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrsumabs": "accumulator = incrsumabs();\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrsumabs2": "accumulator = incrsumabs2();\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrsummary": "accumulator = incrsummary();\ns = accumulator()\ns = accumulator( 2.0 )\ns = accumulator( -5.0 )\ns = accumulator()\n",
- "incrsumprod": "accumulator = incrsumprod();\ns = accumulator()\ns = accumulator( 2.0, 3.0 )\ns = accumulator( -5.0, 2.0 )\ns = accumulator()\n",
- "incrvariance": "accumulator = incrvariance();\ns2 = accumulator()\ns2 = accumulator( 2.0 )\ns2 = accumulator( -5.0 )\ns2 = accumulator()\n",
- "incrvmr": "accumulator = incrvmr();\nD = accumulator()\nD = accumulator( 2.0 )\nD = accumulator( 1.0 )\nD = accumulator()\n",
- "incrwmean": "accumulator = incrwmean();\nmu = accumulator()\nmu = accumulator( 2.0, 1.0 )\nmu = accumulator( 2.0, 0.5 )\nmu = accumulator( 3.0, 1.5 )\nmu = accumulator()\n",
- "ind2sub": "d = [ 3, 3, 3 ];\ns = ind2sub( d, 17 )\n\n// Provide an output array:\nout = new Array( d.length );\ns = ind2sub( out, d, 17 )\nbool = ( s === out )\n",
- "indexOf": "\n// Basic usage:\narr = [ 4, 3, 2, 1 ];\nidx = indexOf( arr, 3 )\narr = [ 4, 3, 2, 1 ];\nidx = indexOf( arr, 5 )\n\n// Using a `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, 3 )\n\n// `fromIndex` which exceeds `array` length:\narr = [ 1, 2, 3, 4, 2, 5 ];\nidx = indexOf( arr, 2, 10 )\n\n// Negative `fromIndex`:\narr = [ 1, 2, 3, 4, 5, 2, 6, 2 ];\nidx = indexOf( arr, 2, -4 )\nidx = indexOf( arr, 2, -1 )\n\n// Negative `fromIndex` exceeding input `array` length:\narr = [ 1, 2, 3, 4, 5, 2, 6 ];\nidx = indexOf( arr, 2, -10 )\n\n// Array-like objects:\nstr = 'bebop';\nidx = indexOf( str, 'o' )\n",
- "inherit": "\n// Create a parent constructor:\nfunction Foo() { return this; };\nFoo.prototype.beep = function beep() { return 'boop'; };\n\n// Create a child constructor:\nfunction Bar() { Foo.call( this ); return this; };\n\n// Setup inheritance:\ninherit( Bar, Foo );\nbar = new Bar();\nv = bar.beep()\n",
- "inheritedEnumerableProperties": "props = inheritedEnumerableProperties( {} )\n",
- "inheritedEnumerablePropertySymbols": "symbols = inheritedEnumerablePropertySymbols( [] )\n",
- "inheritedKeys": "keys = inheritedKeys( {} )\n",
- "inheritedNonEnumerableProperties": "props = inheritedNonEnumerableProperties( {} )\n",
- "inheritedNonEnumerablePropertyNames": "keys = inheritedNonEnumerablePropertyNames( {} )\n",
- "inheritedNonEnumerablePropertySymbols": "symbols = inheritedNonEnumerablePropertySymbols( [] )\n",
- "inheritedProperties": "symbols = inheritedProperties( [] )\n",
- "inheritedPropertyDescriptor": "desc = inheritedPropertyDescriptor( {}, 'toString' )\n",
- "inheritedPropertyDescriptors": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\ndesc = inheritedPropertyDescriptors( obj )\n",
- "inheritedPropertyNames": "keys = inheritedPropertyNames( [] )\n",
- "inheritedPropertySymbols": "symbols = inheritedPropertySymbols( [] )\n",
- "inheritedWritableProperties": "props = inheritedWritableProperties( {} )\n",
- "inheritedWritablePropertyNames": "keys = inheritedWritablePropertyNames( {} )\n",
- "inheritedWritablePropertySymbols": "symbols = inheritedWritablePropertySymbols( [] )\n",
- "inmap": "function foo( v, i ) { return v * i; };\narr = [ 1.0, 2.0, 3.0 ];\nout = inmap( arr, foo )\nbool = ( out === arr )\n",
- "inmapAsync": "\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\narr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\ninmapAsync( arr, opts, fcn, done )\n",
- "inmapRight": "function foo( v, i ) { console.log( '%s: %d', i, v ); return v * i; };\narr = [ 1.0, 2.0, 3.0 ];\nout = inmapRight( arr, foo )\nbool = ( out === arr )\n",
- "inmapRightAsync": "\n// Basic usage:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\narr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n\n// Process sequentially:\nfunction fcn( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, value*index );\n }\n};\nfunction done( error, collection ) {\n if ( error ) {\n throw error;\n }\n console.log( collection === arr );\n console.log( collection );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\ninmapRightAsync( arr, opts, fcn, done )\n",
- "inspectSinkStream": "function clbk( chunk, idx ) { console.log( chunk.toString() ); };\ns = inspectSinkStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "inspectStream": "function clbk( chunk, idx ) { console.log( chunk.toString() ); };\ns = inspectStream( clbk );\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "instanceOf": "bool = instanceOf( [], Array )\nbool = instanceOf( {}, Object )\nbool = instanceOf( null, Object )\n",
- "INT8_MAX": "INT8_MAX\n",
- "INT8_MIN": "INT8_MIN\n",
- "INT8_NUM_BYTES": "INT8_NUM_BYTES\n",
- "Int8Array": "arr = new Int8Array()\n",
- "INT16_MAX": "INT16_MAX\n",
- "INT16_MIN": "INT16_MIN\n",
- "INT16_NUM_BYTES": "INT16_NUM_BYTES\n",
- "Int16Array": "arr = new Int16Array()\n",
- "INT32_MAX": "INT32_MAX\n",
- "INT32_MIN": "INT32_MIN\n",
- "INT32_NUM_BYTES": "INT32_NUM_BYTES\n",
- "Int32Array": "arr = new Int32Array()\n",
- "IS_BIG_ENDIAN": "IS_BIG_ENDIAN\n",
- "IS_BROWSER": "IS_BROWSER\n",
- "IS_DARWIN": "IS_DARWIN\n",
- "IS_ELECTRON": "IS_ELECTRON\n",
- "IS_ELECTRON_MAIN": "IS_ELECTRON_MAIN\n",
- "IS_ELECTRON_RENDERER": "IS_ELECTRON_RENDERER\n",
- "IS_LITTLE_ENDIAN": "IS_LITTLE_ENDIAN\n",
- "IS_NODE": "IS_NODE\n",
- "IS_WEB_WORKER": "IS_WEB_WORKER\n",
- "IS_WINDOWS": "IS_WINDOWS\n",
- "isAbsolutePath": "\n// Windows environment:\nbool = isAbsolutePath( 'C:\\\\foo\\\\bar\\\\baz' )\n\n// POSIX environment:\nbool = isAbsolutePath( '/foo/bar/baz' )\n",
- "isAccessorProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nbool = isAccessorProperty( obj, 'boop' )\nbool = isAccessorProperty( obj, 'beep' )\n",
- "isAccessorPropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nbool = isAccessorPropertyIn( obj, 'boop' )\nbool = isAccessorPropertyIn( obj, 'beep' )\n",
- "isAlphagram": "out = isAlphagram( 'beep' )\nout = isAlphagram( 'zba' )\nout = isAlphagram( '' )\n",
- "isAlphaNumeric": "bool = isAlphaNumeric( 'abc0123456789' )\nbool = isAlphaNumeric( 'abcdef' )\nbool = isAlphaNumeric( '0xff' )\nbool = isAlphaNumeric( '' )\n",
- "isAnagram": "str1 = 'I am a weakish speller';\nstr2 = 'William Shakespeare';\nbool = isAnagram( str1, str2 )\nbool = isAnagram( 'bat', 'tabba' )\n",
- "isArguments": "function foo() { return arguments; };\nbool = isArguments( foo() )\nbool = isArguments( [] )\n",
- "isArray": "bool = isArray( [] )\nbool = isArray( {} )\n",
- "isArrayArray": "bool = isArrayArray( [ [], [] ] )\nbool = isArrayArray( [ {}, {} ] )\nbool = isArrayArray( [] )\n",
- "isArrayBuffer": "bool = isArrayBuffer( new ArrayBuffer( 10 ) )\nbool = isArrayBuffer( [] )\n",
- "isArrayLength": "bool = isArrayLength( 5 )\nbool = isArrayLength( 2.0e200 )\nbool = isArrayLength( -3.14 )\nbool = isArrayLength( null )\n",
- "isArrayLike": "bool = isArrayLike( [] )\nbool = isArrayLike( { 'length': 10 } )\nbool = isArrayLike( 'beep' )\nbool = isArrayLike( null )\n",
- "isArrayLikeObject": "bool = isArrayLikeObject( [] )\nbool = isArrayLikeObject( { 'length': 10 } )\nbool = isArrayLikeObject( 'beep' )\n",
- "isASCII": "str = 'beep boop';\nbool = isASCII( str )\nbool = isASCII( fromCodePoint( 130 ) )\n",
- "isBetween": "bool = isBetween( 3.14, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.0, 4.0 )\nbool = isBetween( 4.0, 3.0, 4.0 )\nbool = isBetween( 3.0, 3.14, 4.0 )\nbool = isBetween( 3.14, 3.14, 4.0, 'open', 'closed' )\nbool = isBetween( 3.14, 3.0, 3.14, 'closed', 'open' )\n",
- "isBetweenArray": "arr = [ 3.0, 3.14, 4.0 ];\nbool = isBetweenArray( arr, 3.0, 4.0 )\nbool = isBetweenArray( arr, 3.14, 4.0 )\nbool = isBetweenArray( arr, 3.0, 3.14 )\nbool = isBetweenArray( arr, 3.0, 4.0, 'open', 'closed' )\nbool = isBetweenArray( arr, 3.0, 4.0, 'closed', 'open' )\n",
- "isBinaryString": "bool = isBinaryString( '1000101' )\nbool = isBinaryString( 'beep' )\nbool = isBinaryString( '' )\n",
- "isBoolean": "bool = isBoolean( false )\nbool = isBoolean( new Boolean( false ) )\n",
- "isBooleanArray": "bool = isBooleanArray( [ true, false, true ] )\nbool = isBooleanArray( [ true, 'abc', false ] )\n",
- "isBoxedPrimitive": "bool = isBoxedPrimitive( new Boolean( false ) )\nbool = isBoxedPrimitive( true )\n",
- "isBuffer": "bool = isBuffer( new Buffer( 'beep' ) )\nbool = isBuffer( new Buffer( [ 1, 2, 3, 4 ] ) )\nbool = isBuffer( {} )\nbool = isBuffer( [] )\n",
- "isCapitalized": "bool = isCapitalized( 'Hello' )\nbool = isCapitalized( 'world' )\n",
- "isCentrosymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 2, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isCentrosymmetricMatrix( M )\nbool = isCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isCentrosymmetricMatrix( 3.14 )\nbool = isCentrosymmetricMatrix( {} )\n",
- "isCircular": "obj = { 'beep': 'boop' };\nobj.self = obj;\nbool = isCircular( obj )\nbool = isCircular( {} )\nbool = isCircular( null )\n",
- "isCircularArray": "arr = [ 1, 2, 3 ];\narr.push( arr );\nbool = isCircularArray( arr )\nbool = isCircularArray( [] )\nbool = isCircularArray( null )\n",
- "isCircularPlainObject": "obj = { 'beep': 'boop' };\nobj.self = obj;\nbool = isCircularPlainObject( obj )\nbool = isCircularPlainObject( {} )\nbool = isCircularPlainObject( null )\n",
- "isCollection": "bool = isCollection( [] )\nbool = isCollection( { 'length': 0 } )\nbool = isCollection( {} )\n",
- "isComplex": "bool = isComplex( new Complex64( 2.0, 2.0 ) )\nbool = isComplex( new Complex128( 3.0, 1.0 ) )\nbool = isComplex( 3.14 )\nbool = isComplex( {} )\n",
- "isComplex64": "bool = isComplex64( new Complex64( 2.0, 2.0 ) )\nbool = isComplex64( new Complex128( 3.0, 1.0 ) )\nbool = isComplex64( 3.14 )\nbool = isComplex64( {} )\n",
- "isComplex64Array": "bool = isComplex64Array( new Complex64Array( 10 ) )\nbool = isComplex64Array( [] )\n",
- "isComplex128": "bool = isComplex128( new Complex128( 3.0, 1.0 ) )\nbool = isComplex128( new Complex64( 2.0, 2.0 ) )\nbool = isComplex128( 3.14 )\nbool = isComplex128( {} )\n",
- "isComplex128Array": "bool = isComplex128Array( new Complex128Array( 10 ) )\nbool = isComplex128Array( [] )\n",
- "isComplexLike": "bool = isComplexLike( new Complex64( 2.0, 2.0 ) )\nbool = isComplexLike( new Complex128( 3.0, 1.0 ) )\nbool = isComplexLike( 3.14 )\nbool = isComplexLike( {} )\n",
- "isComplexTypedArray": "bool = isComplexTypedArray( new Complex64Array( 10 ) )\n",
- "isConfigurableProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isConfigurableProperty( obj, 'boop' )\nbool = isConfigurableProperty( obj, 'beep' )\n",
- "isConfigurablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isConfigurablePropertyIn( obj, 'boop' )\nbool = isConfigurablePropertyIn( obj, 'beep' )\n",
- "isDataProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nbool = isDataProperty( obj, 'boop' )\nbool = isDataProperty( obj, 'beep' )\n",
- "isDataPropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.get = function getter() { return 'beep'; };\ndefineProperty( obj, 'beep', desc );\nbool = isDataPropertyIn( obj, 'boop' )\nbool = isDataPropertyIn( obj, 'beep' )\n",
- "isDateObject": "bool = isDateObject( new Date() )\nbool = isDateObject( '2017-01-01' )\n",
- "isDigitString": "bool = isDigitString( '0123456789' )\nbool = isDigitString( 'abcdef' )\nbool = isDigitString( '0xff' )\nbool = isDigitString( '' )\n",
- "isEmailAddress": "bool = isEmailAddress( 'beep@boop.com' )\nbool = isEmailAddress( 'beep' )\nbool = isEmailAddress( null )\n",
- "isEmptyArray": "bool = isEmptyArray( [] )\nbool = isEmptyArray( [ 1, 2, 3 ] )\nbool = isEmptyArray( {} )\n",
- "isEmptyObject": "bool = isEmptyObject( {} )\nbool = isEmptyObject( { 'beep': 'boop' } )\nbool = isEmptyObject( [] )\n",
- "isEmptyString": "bool = isEmptyString( '' )\nbool = isEmptyString( new String( '' ) )\nbool = isEmptyString( 'beep' )\nbool = isEmptyString( [] )\n",
- "isEnumerableProperty": "beep = { 'boop': true };\nbool = isEnumerableProperty( beep, 'boop' )\nbool = isEnumerableProperty( beep, 'hasOwnProperty' )\n",
- "isEnumerablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isEnumerablePropertyIn( obj, 'boop' )\nbool = isEnumerablePropertyIn( obj, 'beep' )\n",
- "isError": "bool = isError( new Error( 'beep' ) )\nbool = isError( {} )\n",
- "isEvalError": "bool = isEvalError( new EvalError( 'beep' ) )\nbool = isEvalError( {} )\n",
- "isEven": "bool = isEven( 4.0 )\nbool = isEven( new Number( 4.0 ) )\nbool = isEven( 3.0 )\nbool = isEven( -3.14 )\nbool = isEven( null )\n",
- "isFalsy": "bool = isFalsy( false )\nbool = isFalsy( '' )\nbool = isFalsy( 0 )\nbool = isFalsy( null )\nbool = isFalsy( void 0 )\nbool = isFalsy( NaN )\nbool = isFalsy( {} )\nbool = isFalsy( [] )\n",
- "isFalsyArray": "bool = isFalsyArray( [ null, '' ] )\nbool = isFalsyArray( [ {}, [] ] )\nbool = isFalsyArray( [] )\n",
- "isFinite": "bool = isFinite( 5.0 )\nbool = isFinite( new Number( 5.0 ) )\nbool = isFinite( 1.0/0.0 )\nbool = isFinite( null )\n",
- "isFiniteArray": "bool = isFiniteArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isFiniteArray( [ -3.0, 1.0/0.0 ] )\n",
- "isFloat32Array": "bool = isFloat32Array( new Float32Array( 10 ) )\nbool = isFloat32Array( [] )\n",
- "isFloat64Array": "bool = isFloat64Array( new Float64Array( 10 ) )\nbool = isFloat64Array( [] )\n",
- "isFunction": "function beep() {};\nbool = isFunction( beep )\nbool = isFunction( {} )\n",
- "isFunctionArray": "function beep() {};\nfunction boop() {};\nbool = isFunctionArray( [ beep, boop ] )\nbool = isFunctionArray( [ {}, beep ] )\nbool = isFunctionArray( [] )\n",
- "isGeneratorObject": "function* generateID() {\n var idx = 0;\n while ( idx < idx+1 ) {\n yield idx;\n idx += 1;\n }\n};\nbool = isGeneratorObject( generateID() )\nbool = isGeneratorObject( generateID )\nbool = isGeneratorObject( {} )\nbool = isGeneratorObject( null )\n",
- "isGeneratorObjectLike": "obj = {\n 'next': function noop() {},\n 'return': function noop() {},\n 'throw': function noop() {}\n};\nbool = isGeneratorObjectLike( obj )\nbool = isGeneratorObjectLike( {} )\nbool = isGeneratorObjectLike( null )\n",
- "isHexString": "bool = isHexString( '0123456789abcdefABCDEF' )\nbool = isHexString( '0xffffff' )\nbool = isHexString( 'x' )\nbool = isHexString( '' )\n",
- "isInfinite": "bool = isInfinite( 1.0/0.0 )\nbool = isInfinite( new Number( -1.0/0.0 ) )\nbool = isInfinite( 5.0 )\nbool = isInfinite( '1.0/0.0' )\n",
- "isInheritedProperty": "beep = { 'boop': true };\nbool = isInheritedProperty( beep, 'boop' )\nbool = isInheritedProperty( beep, 'toString' )\nbool = isInheritedProperty( beep, 'bop' )\n",
- "isInt8Array": "bool = isInt8Array( new Int8Array( 10 ) )\nbool = isInt8Array( [] )\n",
- "isInt16Array": "bool = isInt16Array( new Int16Array( 10 ) )\nbool = isInt16Array( [] )\n",
- "isInt32Array": "bool = isInt32Array( new Int32Array( 10 ) )\nbool = isInt32Array( [] )\n",
- "isInteger": "bool = isInteger( 5.0 )\nbool = isInteger( new Number( 5.0 ) )\nbool = isInteger( -3.14 )\nbool = isInteger( null )\n",
- "isIntegerArray": "bool = isIntegerArray( [ -3.0, new Number(0.0), 2.0 ] )\nbool = isIntegerArray( [ -3.0, '3.0' ] )\n",
- "isIterableLike": "bool = isIterableLike( [ 1, 2, 3 ] )\nbool = isIterableLike( {} )\nbool = isIterableLike( null )\n",
- "isIteratorLike": "obj = {\n 'next': function noop() {}\n};\nbool = isIteratorLike( obj )\nbool = isIteratorLike( {} )\nbool = isIteratorLike( null )\n",
- "isJSON": "bool = isJSON( '{\"a\":5}' )\nbool = isJSON( '{a\":5}' )\n",
- "isLeapYear": "bool = isLeapYear( new Date() )\nbool = isLeapYear( 1996 )\nbool = isLeapYear( 2001 )\n",
- "isLowercase": "bool = isLowercase( 'hello' )\nbool = isLowercase( 'World' )\n",
- "isMatrixLike": "M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nbool = isMatrixLike( M )\nbool = isMatrixLike( [ 1, 2, 3, 4 ] )\nbool = isMatrixLike( 3.14 )\nbool = isMatrixLike( {} )\n",
- "isMethod": "beep = { 'boop': function beep() { return 'beep'; } };\nbool = isMethod( beep, 'boop' )\nbool = isMethod( beep, 'toString' )\n",
- "isMethodIn": "beep = { 'boop': true };\nbool = isMethodIn( beep, 'toString' )\nbool = isMethodIn( beep, 'boop' )\nbool = isMethodIn( beep, 'bop' )\n",
- "isNamedTypedTupleLike": "Point = namedtypedtuple( [ 'x', 'y' ] );\np = new Point();\nbool = isNamedTypedTupleLike( p )\nbool = isNamedTypedTupleLike( [ 1, 2, 3, 4 ] )\nbool = isNamedTypedTupleLike( 3.14 )\nbool = isNamedTypedTupleLike( {} )\n",
- "isnan": "bool = isnan( NaN )\nbool = isnan( new Number( NaN ) )\nbool = isnan( 3.14 )\nbool = isnan( null )\n",
- "isNaNArray": "bool = isNaNArray( [ NaN, NaN, NaN ] )\nbool = isNaNArray( [ NaN, 2 ] )\n",
- "isNativeFunction": "bool = isNativeFunction( Date )\nfunction beep() {};\nbool = isNativeFunction( beep )\nbool = isNativeFunction( {} )\n",
- "isndarrayLike": "M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 2;\nM.shape = [ 2, 2 ];\nM.strides = [ 2, 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nbool = isndarrayLike( M )\nbool = isndarrayLike( [ 1, 2, 3, 4 ] )\nbool = isndarrayLike( 3.14 )\nbool = isndarrayLike( {} )\n",
- "isNegativeInteger": "bool = isNegativeInteger( -5.0 )\nbool = isNegativeInteger( new Number( -5.0 ) )\nbool = isNegativeInteger( 5.0 )\nbool = isNegativeInteger( -3.14 )\nbool = isNegativeInteger( null )\n",
- "isNegativeIntegerArray": "bool = isNegativeIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeIntegerArray( [ -3.0, '-3.0' ] )\n",
- "isNegativeNumber": "bool = isNegativeNumber( -5.0 )\nbool = isNegativeNumber( new Number( -5.0 ) )\nbool = isNegativeNumber( -3.14 )\nbool = isNegativeNumber( 5.0 )\nbool = isNegativeNumber( null )\n",
- "isNegativeNumberArray": "bool = isNegativeNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNegativeNumberArray( [ -3.0, '-3.0' ] )\n",
- "isNegativeZero": "bool = isNegativeZero( -0.0 )\nbool = isNegativeZero( new Number( -0.0 ) )\nbool = isNegativeZero( -3.14 )\nbool = isNegativeZero( 0.0 )\nbool = isNegativeZero( null )\n",
- "isNodeBuiltin": "bool = isNodeBuiltin( 'cluster' )\nbool = isNodeBuiltin( 'crypto' )\nbool = isNodeBuiltin( 'fs-extra' )\nbool = isNodeBuiltin( '' )\n",
- "isNodeDuplexStreamLike": "Stream = require( 'stream' ).Duplex;\ns = new Stream();\nbool = isNodeDuplexStreamLike( s )\nbool = isNodeDuplexStreamLike( {} )\n",
- "isNodeReadableStreamLike": "Stream = require( 'stream' ).Readable;\ns = new Stream();\nbool = isNodeReadableStreamLike( s )\nbool = isNodeReadableStreamLike( {} )\n",
- "isNodeREPL": "bool = isNodeREPL()\n",
- "isNodeStreamLike": "Stream = require( 'stream' ).Stream;\ns = new Stream();\nbool = isNodeStreamLike( s )\nbool = isNodeStreamLike( {} )\n",
- "isNodeTransformStreamLike": "Stream = require( 'stream' ).Transform;\ns = new Stream();\nbool = isNodeTransformStreamLike( s )\nbool = isNodeTransformStreamLike( {} )\n",
- "isNodeWritableStreamLike": "Stream = require( 'stream' ).Writable;\ns = new Stream();\nbool = isNodeWritableStreamLike( s )\nbool = isNodeWritableStreamLike( {} )\n",
- "isNonConfigurableProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nbool = isNonConfigurableProperty( obj, 'boop' )\nbool = isNonConfigurableProperty( obj, 'beep' )\n",
- "isNonConfigurablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isNonConfigurablePropertyIn( obj, 'boop' )\nbool = isNonConfigurablePropertyIn( obj, 'beep' )\n",
- "isNonEnumerableProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nbool = isNonEnumerableProperty( obj, 'boop' )\nbool = isNonEnumerableProperty( obj, 'beep' )\n",
- "isNonEnumerablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = true;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isNonEnumerablePropertyIn( obj, 'boop' )\nbool = isNonEnumerablePropertyIn( obj, 'beep' )\n",
- "isNonNegativeInteger": "bool = isNonNegativeInteger( 5.0 )\nbool = isNonNegativeInteger( new Number( 5.0 ) )\nbool = isNonNegativeInteger( 3.14 )\nbool = isNonNegativeInteger( -5.0 )\nbool = isNonNegativeInteger( null )\n",
- "isNonNegativeIntegerArray": "bool = isNonNegativeIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeIntegerArray( [ 3.0, '3.0' ] )\n",
- "isNonNegativeNumber": "bool = isNonNegativeNumber( 5.0 )\nbool = isNonNegativeNumber( new Number( 5.0 ) )\nbool = isNonNegativeNumber( 3.14 )\nbool = isNonNegativeNumber( -5.0 )\nbool = isNonNegativeNumber( null )\n",
- "isNonNegativeNumberArray": "bool = isNonNegativeNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isNonNegativeNumberArray( [ 3.0, '3.0' ] )\n",
- "isNonPositiveInteger": "bool = isNonPositiveInteger( -5.0 )\nbool = isNonPositiveInteger( new Number( -5.0 ) )\nbool = isNonPositiveInteger( 5.0 )\nbool = isNonPositiveInteger( -3.14 )\nbool = isNonPositiveInteger( null )\n",
- "isNonPositiveIntegerArray": "bool = isNonPositiveIntegerArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveIntegerArray( [ -3.0, '-3.0' ] )\n",
- "isNonPositiveNumber": "bool = isNonPositiveNumber( -5.0 )\nbool = isNonPositiveNumber( new Number( -5.0 ) )\nbool = isNonPositiveNumber( -3.14 )\nbool = isNonPositiveNumber( 5.0 )\nbool = isNonPositiveNumber( null )\n",
- "isNonPositiveNumberArray": "bool = isNonPositiveNumberArray( [ -3.0, new Number(-3.0) ] )\nbool = isNonPositiveNumberArray( [ -3.0, '-3.0' ] )\n",
- "isNonSymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 1, 2, 3, 4 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isNonSymmetricMatrix( M )\nbool = isNonSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isNonSymmetricMatrix( 3.14 )\nbool = isNonSymmetricMatrix( {} )\n",
- "isNull": "bool = isNull( null )\nbool = isNull( true )\n",
- "isNullArray": "bool = isNullArray( [ null, null, null ] )\nbool = isNullArray( [ NaN, 2, null ] )\n",
- "isNumber": "bool = isNumber( 3.14 )\nbool = isNumber( new Number( 3.14 ) )\nbool = isNumber( NaN )\nbool = isNumber( null )\n",
- "isNumberArray": "bool = isNumberArray( [ 1, 2, 3 ] )\nbool = isNumberArray( [ '1', 2, 3 ] )\n",
- "isNumericArray": "bool = isNumericArray( new Int8Array( 10 ) )\nbool = isNumericArray( [ 1, 2, 3 ] )\nbool = isNumericArray( [ '1', '2', '3' ] )\n",
- "isObject": "bool = isObject( {} )\nbool = isObject( true )\n",
- "isObjectArray": "bool = isObjectArray( [ {}, new Number(3.0) ] )\nbool = isObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isObjectArray( [ {}, '3.0' ] )\n",
- "isObjectLike": "bool = isObjectLike( {} )\nbool = isObjectLike( [] )\nbool = isObjectLike( null )\n",
- "isOdd": "bool = isOdd( 5.0 )\nbool = isOdd( new Number( 5.0 ) )\nbool = isOdd( 4.0 )\nbool = isOdd( new Number( 4.0 ) )\nbool = isOdd( -3.14 )\nbool = isOdd( null )\n",
- "isoWeeksInYear": "num = isoWeeksInYear()\nnum = isoWeeksInYear( 2015 )\nnum = isoWeeksInYear( 2017 )\n",
- "isPersymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 1, 2, 3, 1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isPersymmetricMatrix( M )\nbool = isPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isPersymmetricMatrix( 3.14 )\nbool = isPersymmetricMatrix( {} )\n",
- "isPlainObject": "bool = isPlainObject( {} )\nbool = isPlainObject( null )\n",
- "isPlainObjectArray": "bool = isPlainObjectArray( [ {}, { 'beep': 'boop' } ] )\nbool = isPlainObjectArray( [ {}, new Number(3.0) ] )\nbool = isPlainObjectArray( [ {}, '3.0' ] )\n",
- "isPositiveInteger": "bool = isPositiveInteger( 5.0 )\nbool = isPositiveInteger( new Number( 5.0 ) )\nbool = isPositiveInteger( 3.14 )\nbool = isPositiveInteger( -5.0 )\nbool = isPositiveInteger( null )\n",
- "isPositiveIntegerArray": "bool = isPositiveIntegerArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveIntegerArray( [ 3.0, '3.0' ] )\n",
- "isPositiveNumber": "bool = isPositiveNumber( 5.0 )\nbool = isPositiveNumber( new Number( 5.0 ) )\nbool = isPositiveNumber( 3.14 )\nbool = isPositiveNumber( -5.0 )\nbool = isPositiveNumber( null )\n",
- "isPositiveNumberArray": "bool = isPositiveNumberArray( [ 3.0, new Number(3.0) ] )\nbool = isPositiveNumberArray( [ 3.0, '3.0' ] )\n",
- "isPositiveZero": "bool = isPositiveZero( 0.0 )\nbool = isPositiveZero( new Number( 0.0 ) )\nbool = isPositiveZero( -3.14 )\nbool = isPositiveZero( -0.0 )\nbool = isPositiveZero( null )\n",
- "isPrimitive": "bool = isPrimitive( true )\nbool = isPrimitive( {} )\n",
- "isPrimitiveArray": "bool = isPrimitiveArray( [ '3', 2, null ] )\nbool = isPrimitiveArray( [ {}, 2, 1 ] )\nbool = isPrimitiveArray( [ new String('abc'), '3.0' ] )\n",
- "isPRNGLike": "bool = isPRNGLike( base.random.randu )\nbool = isPRNGLike( [ 1, 2, 3, 4 ] )\nbool = isPRNGLike( 3.14 )\nbool = isPRNGLike( {} )\n",
- "isProbability": "bool = isProbability( 0.5 )\nbool = isProbability( new Number( 0.5 ) )\nbool = isProbability( 3.14 )\nbool = isProbability( -5.0 )\nbool = isProbability( null )\n",
- "isProbabilityArray": "bool = isProbabilityArray( [ 0.5, new Number(0.8) ] )\nbool = isProbabilityArray( [ 0.8, 1.2 ] )\nbool = isProbabilityArray( [ 0.8, '0.2' ] )\n",
- "isPrototypeOf": "function Foo() { return this; };\nfunction Bar() { return this; };\ninherit( Bar, Foo );\nbar = new Bar();\nbool = isPrototypeOf( bar, Foo.prototype )\n",
- "isRangeError": "bool = isRangeError( new RangeError( 'beep' ) )\nbool = isRangeError( {} )\n",
- "isReadableProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isReadableProperty( obj, 'boop' )\nbool = isReadableProperty( obj, 'beep' )\n",
- "isReadablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isReadablePropertyIn( obj, 'boop' )\nbool = isReadablePropertyIn( obj, 'beep' )\n",
- "isReadOnlyProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isReadOnlyProperty( obj, 'boop' )\nbool = isReadOnlyProperty( obj, 'beep' )\n",
- "isReadOnlyPropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = true;\ndefineProperty( obj, 'beep', desc );\nbool = isReadOnlyPropertyIn( obj, 'boop' )\nbool = isReadOnlyPropertyIn( obj, 'beep' )\n",
- "isReadWriteProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isReadWriteProperty( obj, 'boop' )\nbool = isReadWriteProperty( obj, 'beep' )\n",
- "isReadWritePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isReadWritePropertyIn( obj, 'boop' )\nbool = isReadWritePropertyIn( obj, 'beep' )\n",
- "isReferenceError": "bool = isReferenceError( new ReferenceError( 'beep' ) )\nbool = isReferenceError( {} )\n",
- "isRegExp": "bool = isRegExp( /\\.+/ )\nbool = isRegExp( {} )\n",
- "isRegExpString": "bool = isRegExpString( '/beep/' )\nbool = isRegExpString( 'beep' )\nbool = isRegExpString( '' )\nbool = isRegExpString( null )\n",
- "isRelativePath": "\n// Windows environments:\nbool = isRelativePath( 'foo\\\\bar\\\\baz' )\n\n// POSIX environments:\nbool = isRelativePath( './foo/bar/baz' )\n",
- "isSafeInteger": "bool = isSafeInteger( 5.0 )\nbool = isSafeInteger( new Number( 5.0 ) )\nbool = isSafeInteger( 2.0e200 )\nbool = isSafeInteger( -3.14 )\nbool = isSafeInteger( null )\n",
- "isSafeIntegerArray": "arr = [ -3.0, new Number(0.0), 2.0 ];\nbool = isSafeIntegerArray( arr )\narr = [ -3.0, '3.0' ];\nbool = isSafeIntegerArray( arr )\n",
- "isSameValue": "bool = isSameValue( true, true )\nbool = isSameValue( {}, {} )\nbool = isSameValue( -0.0, -0.0 )\nbool = isSameValue( -0.0, 0.0 )\nbool = isSameValue( NaN, NaN )\n",
- "isSameValueZero": "bool = isSameValueZero( true, true )\nbool = isSameValueZero( {}, {} )\nbool = isSameValueZero( -0.0, -0.0 )\nbool = isSameValueZero( -0.0, 0.0 )\nbool = isSameValueZero( NaN, NaN )\n",
- "isSharedArrayBuffer": "\n// Assuming an environment supports SharedArrayBuffer...\nbool = isSharedArrayBuffer( new SharedArrayBuffer( 10 ) )\nbool = isSharedArrayBuffer( [] )\n",
- "isSkewCentrosymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 2, 1, -1, -2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isSkewCentrosymmetricMatrix( M )\nbool = isSkewCentrosymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewCentrosymmetricMatrix( 3.14 )\nbool = isSkewCentrosymmetricMatrix( {} )\n",
- "isSkewPersymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 1, 0, 0, -1 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isSkewPersymmetricMatrix( M )\nbool = isSkewPersymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewPersymmetricMatrix( 3.14 )\nbool = isSkewPersymmetricMatrix( {} )\n",
- "isSkewSymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 0, -1, 1, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isSkewSymmetricMatrix( M )\nbool = isSkewSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSkewSymmetricMatrix( 3.14 )\nbool = isSkewSymmetricMatrix( {} )\n",
- "isSquareMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 0, 0, 0, 0 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isSquareMatrix( M )\nbool = isSquareMatrix( [ 1, 2, 3, 4 ] )\nbool = isSquareMatrix( 3.14 )\nbool = isSquareMatrix( {} )\n",
- "isStrictEqual": "bool = isStrictEqual( true, true )\nbool = isStrictEqual( {}, {} )\nbool = isStrictEqual( -0.0, -0.0 )\nbool = isStrictEqual( -0.0, 0.0 )\nbool = isStrictEqual( NaN, NaN )\n",
- "isString": "bool = isString( 'beep' )\nbool = isString( new String( 'beep' ) )\nbool = isString( 5 )\n",
- "isStringArray": "bool = isStringArray( [ 'abc', 'def' ] )\nbool = isStringArray( [ 'abc', 123 ] )\n",
- "isSymbol": "bool = isSymbol( Symbol( 'beep' ) )\nbool = isSymbol( Object( Symbol( 'beep' ) ) )\nbool = isSymbol( {} )\nbool = isSymbol( null )\nbool = isSymbol( true )\n",
- "isSymbolArray": "bool = isSymbolArray( [ Symbol( 'beep' ), Symbol( 'boop' ) ] )\nbool = isSymbolArray( Symbol( 'beep' ) )\nbool = isSymbolArray( [] )\nbool = isSymbolArray( {} )\nbool = isSymbolArray( null )\nbool = isSymbolArray( true )\n",
- "isSymmetricMatrix": "mat = ndarray( 'generic', 2 );\nM = mat( [ 0, 1, 1, 2 ], [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );\nbool = isSymmetricMatrix( M )\nbool = isSymmetricMatrix( [ 1, 2, 3, 4 ] )\nbool = isSymmetricMatrix( 3.14 )\nbool = isSymmetricMatrix( {} )\n",
- "isSyntaxError": "bool = isSyntaxError( new SyntaxError( 'beep' ) )\nbool = isSyntaxError( {} )\n",
- "isTruthy": "bool = isTruthy( {} )\nbool = isTruthy( [] )\nbool = isTruthy( false )\nbool = isTruthy( '' )\nbool = isTruthy( 0 )\nbool = isTruthy( null )\nbool = isTruthy( void 0 )\nbool = isTruthy( NaN )\n",
- "isTruthyArray": "bool = isTruthyArray( [ {}, [] ] )\nbool = isTruthyArray( [ null, '' ] )\nbool = isTruthyArray( [] )\n",
- "isTypedArray": "bool = isTypedArray( new Int8Array( 10 ) )\n",
- "isTypedArrayLength": "bool = isTypedArrayLength( 5 )\nbool = isTypedArrayLength( 2.0e200 )\nbool = isTypedArrayLength( -3.14 )\nbool = isTypedArrayLength( null )\n",
- "isTypedArrayLike": "bool = isTypedArrayLike( new Int16Array() )\nbool = isTypedArrayLike({\n 'length': 10,\n 'byteOffset': 0,\n 'byteLength': 10,\n 'BYTES_PER_ELEMENT': 4\n})\n",
- "isTypeError": "bool = isTypeError( new TypeError( 'beep' ) )\nbool = isTypeError( {} )\n",
- "isUint8Array": "bool = isUint8Array( new Uint8Array( 10 ) )\nbool = isUint8Array( [] )\n",
- "isUint8ClampedArray": "bool = isUint8ClampedArray( new Uint8ClampedArray( 10 ) )\nbool = isUint8ClampedArray( [] )\n",
- "isUint16Array": "bool = isUint16Array( new Uint16Array( 10 ) )\nbool = isUint16Array( [] )\n",
- "isUint32Array": "bool = isUint32Array( new Uint32Array( 10 ) )\nbool = isUint32Array( [] )\n",
- "isUNCPath": "bool = isUNCPath( '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz' )\nbool = isUNCPath( '/foo/bar/baz' )\n",
- "isUndefined": "bool = isUndefined( void 0 )\nbool = isUndefined( null )\n",
- "isUndefinedOrNull": "bool = isUndefinedOrNull( void 0 )\nbool = isUndefinedOrNull( null )\nbool = isUndefinedOrNull( false )\n",
- "isUnityProbabilityArray": "bool = isUnityProbabilityArray( [ 0.25, 0.5, 0.25 ] )\nbool = isUnityProbabilityArray( new Uint8Array( [ 0, 1 ] ) )\nbool = isUnityProbabilityArray( [ 0.4, 0.4, 0.4 ] )\nbool = isUnityProbabilityArray( [ 3.14, 0.0 ] )\n",
- "isUppercase": "bool = isUppercase( 'HELLO' )\nbool = isUppercase( 'World' )\n",
- "isURI": "bool = isURI( 'http://google.com' )\nbool = isURI( 'http://localhost/' )\nbool = isURI( 'http://example.w3.org/path%20with%20spaces.html' )\nbool = isURI( 'ftp://ftp.is.co.za/rfc/rfc1808.txt' )\n\n// No scheme:\nbool = isURI( '' )\nbool = isURI( 'foo@bar' )\nbool = isURI( '://foo/' )\n\n// Illegal characters:\nbool = isURI( 'http://' )\n\n// Invalid path:\nbool = isURI( 'http:////foo.html' )\n\n// Incomplete hex escapes:\nbool = isURI( 'http://example.w3.org/%a' )\n",
- "isURIError": "bool = isURIError( new URIError( 'beep' ) )\nbool = isURIError( {} )\n",
- "isVectorLike": "M = {};\nM.data = [ 0, 0, 0, 0 ];\nM.ndims = 1;\nM.shape = [ 4 ];\nM.strides = [ 1 ];\nM.offset = 0;\nM.order = 'row-major';\nM.dtype = 'generic';\nM.length = 4;\nM.flags = {};\nM.get = function get( i, j ) {};\nM.set = function set( i, j ) {};\nbool = isVectorLike( M )\nbool = isVectorLike( [ 1, 2, 3, 4 ] )\nbool = isVectorLike( 3.14 )\nbool = isVectorLike( {} )\n",
- "isWhitespace": "bool = isWhitespace( ' ' )\nbool = isWhitespace( 'abcdef' )\nbool = isWhitespace( '' )\n",
- "isWritableProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nbool = isWritableProperty( obj, 'boop' )\nbool = isWritableProperty( obj, 'beep' )\n",
- "isWritablePropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'beep';\ndefineProperty( obj, 'beep', desc );\nbool = isWritablePropertyIn( obj, 'boop' )\nbool = isWritablePropertyIn( obj, 'beep' )\n",
- "isWriteOnlyProperty": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isWriteOnlyProperty( obj, 'boop' )\nbool = isWriteOnlyProperty( obj, 'beep' )\n",
- "isWriteOnlyPropertyIn": "obj = { 'boop': true };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.set = function setter( v ) { obj.boop = v; };\ndefineProperty( obj, 'beep', desc );\nbool = isWriteOnlyPropertyIn( obj, 'boop' )\nbool = isWriteOnlyPropertyIn( obj, 'beep' )\n",
- "iterAdd": "it1 = array2iterator( [ 1.0, 2.0 ] );\nit2 = array2iterator( [ 3.0, 4.0 ] );\nit = iterAdd( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterAdvance": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nit = iterAdvance( arr, 4 );\nv = it.next().value\nbool = it.next().done\n",
- "iterAny": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nbool = iterAny( arr )\n",
- "iterAnyBy": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v === 1 ); };\nbool = iterAnyBy( arr, fcn )\n",
- "iterator2array": "opts = { 'iter': 10 };\narr = iterator2array( random.iterators.randu( opts ) )\n",
- "iterator2arrayview": "it = random.iterators.randu({ 'iter': 10 });\nout = new Float64Array( 20 );\narr = iterator2arrayview( it, out, 5, 15 )\n",
- "iterator2arrayviewRight": "it = random.iterators.randu({ 'iter': 10 });\nout = new Float64Array( 20 );\narr = iterator2arrayviewRight( it, out, 5, 15 )\n",
- "iteratorStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\nit = random.iterators.randu( opts );\ns = iteratorStream( it );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "IteratorSymbol": "s = IteratorSymbol\n",
- "iterawgn": "src = iterSineWave();\nit = iterawgn( src, 0.5 );\nv = it.next().value\nv = it.next().value\n",
- "iterawln": "src = iterSineWave();\nit = iterawln( src, 0.5 );\nv = it.next().value\nv = it.next().value\n",
- "iterawun": "src = iterSineWave();\nit = iterawun( src, 0.5 );\nv = it.next().value\nv = it.next().value\n",
- "iterBartlettHannPulse": "it = iterBartlettHannPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterBartlettPulse": "it = iterBartlettPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterConcat": "it1 = array2iterator( [ 1, 2 ] );\nit2 = array2iterator( [ 3, 4 ] );\nit = iterConcat( it1, it2 );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterConstant": "it = iterConstant( 3.14 );\nv = it.next().value\nv = it.next().value\n",
- "iterCosineWave": "it = iterCosineWave();\nv = it.next().value\nv = it.next().value\n",
- "iterCounter": "it = iterCounter( random.iterators.randu() );\nv = it.next().value\nv = it.next().value\n",
- "itercugmean": "arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nit = itercugmean( arr );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "itercuhmean": "arr = array2iterator( [ 2.0, 5.0, 3.0, 5.0 ] );\nit = itercuhmean( arr );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "itercumax": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumax( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercumaxabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumaxabs( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercumean": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumean( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercumeanabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumeanabs( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercumeanabs2": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumeanabs2( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercumidrange": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumidrange( arr );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "itercumin": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercumin( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercuminabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercuminabs( arr );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itercuprod": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercuprod( arr );\np = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n",
- "itercurange": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercurange( arr );\nr = it.next().value\nr = it.next().value\nr = it.next().value\nr = it.next().value\n",
- "itercusum": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercusum( arr );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "itercusumabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercusumabs( arr );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "itercusumabs2": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itercusumabs2( arr );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "iterDedupe": "arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nit = iterDedupe( arr );\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "iterDedupeBy": "arr = array2iterator( [ 1, 1, 2, 3, 3 ] );\nfunction fcn( v ) { return v; };\nit = iterDedupeBy( arr, fcn );\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "iterDiracComb": "it = iterDiracComb();\nv = it.next().value\nv = it.next().value\n",
- "iterDivide": "it1 = array2iterator( [ 3.0, 2.0 ] );\nit2 = array2iterator( [ 1.0, 4.0 ] );\nit = iterDivide( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterEmpty": "it = iterEmpty();\nbool = it.next().done\n",
- "iterEvery": "arr = array2iterator( [ 1, 1, 1, 1, 0 ] );\nbool = iterEvery( arr )\n",
- "iterEveryBy": "arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nbool = iterEveryBy( arr, fcn )\n",
- "iterFibonacci": "it = iterFibonacci();\nv = it.next().value\nv = it.next().value\n",
- "iterFill": "it = iterFill( random.iterators.randu(), 3.14, 0, 2 );\nr = it.next().value\nr = it.next().value\nr = it.next().value\n",
- "iterFilter": "function f( v ) { return ( v > 2 ); };\nit1 = array2iterator( [ 1, 3, 2, 4 ] );\nit2 = iterFilter( it1, f );\nv = it2.next().value\nv = it2.next().value\n",
- "iterFilterMap": "function f( v ) { if ( v > 2 ) { return v * 10 }; };\nit1 = array2iterator( [ 1, 3, 2, 4 ] );\nit2 = iterFilterMap( it1, f );\nv = it2.next().value\nv = it2.next().value\n",
- "iterFirst": "arr = array2iterator( [ 1, 0, 0, 0, 0 ] );\nv = iterFirst( arr )\n",
- "iterFlatTopPulse": "it = iterFlatTopPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterFlow": "o = {};\no.head = iterHead;\no.some = iterSome;\nfiter = iterFlow( o )\n",
- "iterForEach": "function f( v ) { if ( v !== v ) { throw new Error( 'beep' ); } };\nit = iterForEach( random.iterators.randu(), f );\nr = it.next().value\nr = it.next().value\n",
- "iterHannPulse": "it = iterHannPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterHead": "it = iterHead( random.iterators.randu(), 5 );\nr = it.next().value\nr = it.next().value\n",
- "iterIntersection": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nit2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nit = iterIntersection( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterIntersectionByHash": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nit2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nfunction f( v ) { return v.toString(); };\nit = iterIntersectionByHash( it1, it2, f );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterLanczosPulse": "it = iterLanczosPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterLast": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nv = iterLast( arr )\n",
- "iterLength": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nlen = iterLength( arr )\n",
- "iterMap": "function f( v ) { return v * 10.0; };\nit = iterMap( random.iterators.randu(), f );\nr = it.next().value\nr = it.next().value\n",
- "iterMapN": "it1 = array2iterator( [ 1.0, 2.0 ] );\nit2 = array2iterator( [ 3.0, 4.0 ] );\nfunction fcn( x, y ) { return x + y; };\nit = iterMapN( it1, it2, fcn );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "itermax": "arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nm = itermax( arr )\n",
- "itermaxabs": "arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nm = itermaxabs( arr )\n",
- "itermean": "arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\nm = itermean( arr )\n",
- "itermeanabs": "arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nm = itermeanabs( arr )\n",
- "itermeanabs2": "arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nm = itermeanabs2( arr )\n",
- "itermidrange": "arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nv = itermidrange( arr )\n",
- "itermin": "arr = array2iterator( [ 1.0, -2.0, -3.0, 4.0 ] );\nm = itermin( arr )\n",
- "iterminabs": "arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nm = iterminabs( arr )\n",
- "itermmax": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmax( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermmaxabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmaxabs( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermmean": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmean( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermmeanabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmeanabs( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermmeanabs2": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmeanabs2( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermmidrange": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmidrange( arr, 3 );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\n",
- "itermmin": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermmin( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermminabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermminabs( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "iterMod": "it1 = array2iterator( [ 3.0, 2.0 ] );\nit2 = array2iterator( [ 1.0, 4.0 ] );\nit = iterMod( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "itermprod": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermprod( arr, 3 );\np = it.next().value\np = it.next().value\np = it.next().value\np = it.next().value\n",
- "itermrange": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermrange( arr, 3 );\nm = it.next().value\nm = it.next().value\nm = it.next().value\nm = it.next().value\n",
- "itermsum": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermsum( arr, 3 );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "itermsumabs": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermsumabs( arr, 3 );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "itermsumabs2": "arr = array2iterator( [ 2.0, -5.0, 3.0, 5.0 ] );\nit = itermsumabs2( arr, 3 );\ns = it.next().value\ns = it.next().value\ns = it.next().value\ns = it.next().value\n",
- "iterMultiply": "it1 = array2iterator( [ 1.0, 2.0 ] );\nit2 = array2iterator( [ 3.0, 4.0 ] );\nit = iterMultiply( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterNone": "arr = array2iterator( [ 0, 0, 0, 0, 1 ] );\nbool = iterNone( arr )\n",
- "iterNoneBy": "arr = array2iterator( [ 1, 1, 1, 1, 1 ] );\nfunction fcn( v ) { return ( v <= 0 ); };\nbool = iterNoneBy( arr, fcn )\n",
- "iterNonFibonacci": "it = iterNonFibonacci();\nv = it.next().value\nv = it.next().value\n",
- "iterNth": "arr = array2iterator( [ 0, 0, 1, 0, 0 ] );\nv = iterNth( arr, 3 )\n",
- "iterPeriodicSinc": "it = iterPeriodicSinc( 7 );\nv = it.next().value\nv = it.next().value\n",
- "iterPipeline": "it1 = iterThunk( iterHead, 100 );\nfunction f( r ) { return ( r > 0.95 ); };\nit2 = iterThunk( iterSomeBy, 5, f );\np = iterPipeline( it1, it2 );\nbool = p( random.iterators.randu() )\n",
- "iterPop": "it1 = array2iterator( [ 1, 2 ] );\nit2 = iterPop( it1 );\nv = it2.next().value\nbool = it2.next().done\n",
- "iterprod": "arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\ns = iterprod( arr )\n",
- "iterPulse": "it = iterPulse();\nv = it.next().value\nv = it.next().value\n",
- "iterPush": "it1 = array2iterator( [ 1, 2 ] );\nit2 = iterPush( it1, 3, 4 );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nbool = it2.next().done\n",
- "iterrange": "arr = array2iterator( [ 1.0, -2.0, 3.0, -4.0 ] );\nv = iterrange( arr )\n",
- "iterReject": "function f( v ) { return ( v > 2 ); };\nit1 = array2iterator( [ 1, 3, 2, 4 ] );\nit2 = iterReject( it1, f );\nv = it2.next().value\nv = it2.next().value\n",
- "iterReplicate": "it1 = array2iterator( [ 1, 2, 3, 4 ] );\nit2 = iterReplicate( it1, 2 );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n",
- "iterReplicateBy": "it1 = array2iterator( [ 1, 2, 3, 4 ] );\nfunction f( v, i ) { return i + 1; };\nit2 = iterReplicateBy( it1, f );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\n",
- "iterSawtoothWave": "it = iterSawtoothWave();\nv = it.next().value\nv = it.next().value\n",
- "iterShift": "it1 = array2iterator( [ 1, 2 ] );\nit2 = iterShift( it1 );\nv = it2.next().value\nbool = it2.next().done\n",
- "iterSineWave": "it = iterSineWave();\nv = it.next().value\nv = it.next().value\n",
- "iterSlice": "it = iterSlice( random.iterators.randu(), 5, 10 );\nr = it.next().value\nr = it.next().value\n",
- "iterSome": "arr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nbool = iterSome( arr, 3 )\n",
- "iterSomeBy": "arr = array2iterator( [ 1, 1, 0, 0, 1 ] );\nfunction fcn( v ) { return ( v > 0 ); };\nbool = iterSomeBy( arr, 3, fcn )\n",
- "iterSquareWave": "it = iterSquareWave();\nv = it.next().value\nv = it.next().value\n",
- "iterstdev": "arr = array2iterator( [ 2.0, -5.0 ] );\nm = iterstdev( arr )\n",
- "iterSubtract": "it1 = array2iterator( [ 1.0, 5.0 ] );\nit2 = array2iterator( [ 3.0, 4.0 ] );\nit = iterSubtract( it1, it2 );\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "itersum": "arr = array2iterator( [ 1.0, 2.0, 3.0, 4.0 ] );\ns = itersum( arr )\n",
- "itersumabs": "arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\ns = itersumabs( arr )\n",
- "itersumabs2": "arr = array2iterator( [ -1.0, 2.0, -3.0, 4.0 ] );\ns = itersumabs2( arr )\n",
- "iterThunk": "fcn = iterThunk( iterSome, 3 );\narr = array2iterator( [ 0, 0, 1, 1, 1 ] );\nbool = fcn( arr )\n",
- "iterTriangleWave": "it = iterTriangleWave();\nv = it.next().value\nv = it.next().value\n",
- "iterUnion": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nit2 = array2iterator( [ 1, 2, 5, 2, 3 ] );\nit = iterUnion( it1, it2 );\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nv = it.next().value\nbool = it.next().done\n",
- "iterUnique": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nit2 = iterUnique( it1 );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nbool = it2.next().done\n",
- "iterUniqueBy": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( a, b ) { return ( a !== b ); };\nit2 = iterUniqueBy( it1, f );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nbool = it2.next().done\n",
- "iterUniqueByHash": "it1 = array2iterator( [ 1, 2, 1, 2, 4 ] );\nfunction f( v ) { return v.toString(); };\nit2 = iterUniqueByHash( it1, f );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nbool = it2.next().done\n",
- "iterUnshift": "it1 = array2iterator( [ 1, 2 ] );\nit2 = iterUnshift( it1, 3, 4 );\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nv = it2.next().value\nbool = it2.next().done\n",
- "itervariance": "arr = array2iterator( [ 2.0, -5.0 ] );\ns2 = itervariance( arr )\n",
- "joinStream": "s = joinStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "keyBy": "function toKey( v ) { return v.a; };\narr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyBy( arr, toKey )\n",
- "keyByRight": "function toKey( v ) { return v.a; };\narr = [ { 'a': 1 }, { 'a': 2 } ];\nkeyByRight( arr, toKey )\n",
- "keysIn": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nkeys = keysIn( obj )\n",
- "kruskalTest": "\n// Data from Hollander & Wolfe (1973), p. 116:\nx = [ 2.9, 3.0, 2.5, 2.6, 3.2 ];\ny = [ 3.8, 2.7, 4.0, 2.4 ];\nz = [ 2.8, 3.4, 3.7, 2.2, 2.0 ];\nout = kruskalTest( x, y, z )\narr = [ 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];\ngroups = [\n 'a', 'a', 'a', 'a', 'a',\n 'b', 'b', 'b', 'b',\n 'c', 'c', 'c', 'c', 'c'\n];\nout = kruskalTest( arr, { 'groups': groups })\n",
- "kstest": "\n// Verify that data is drawn from a normal distribution:\nrnorm = base.random.normal.factory({ 'seed': 4839 });\nx = new Array( 100 );\nfor ( var i = 0; i < 100; i++ ) { x[ i ] = rnorm( 3.0, 1.0 ); }\n\n// Test against N(0,1)\nout = kstest( x, 'normal', 0.0, 1.0 )\n\n// Test against N(3,1)\nout = kstest( x, 'normal', 3.0, 1.0 )\n\n// Verify that data is drawn from a uniform distribution:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 })\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0 )\n\n// Print output:\nout.print()\n\n// Set custom significance level:\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alpha': 0.1 })\n\n// Carry out one-sided hypothesis tests:\nrunif = base.random.uniform.factory( 0.0, 1.0, { 'seed': 8798 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) { x[ i ] = runif(); }\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'less' })\nout = kstest( x, 'uniform', 0.0, 1.0, { 'alternative': 'greater' })\n\n// Set `sorted` option to true when data is in increasing order:\nx = [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 ];\nout = kstest( x, 'uniform', 0.0, 1.0, { 'sorted': true })\n",
- "LinkedList": "list = LinkedList();\nlist.push( 'foo' ).push( 'bar' );\nlist.length\nlist.pop()\nlist.length\nlist.pop()\nlist.length\n",
- "linspace": "arr = linspace( 0, 100, 6 )\n",
- "LIU_NEGATIVE_OPINION_WORDS_EN": "list = LIU_NEGATIVE_OPINION_WORDS_EN()\n",
- "LIU_POSITIVE_OPINION_WORDS_EN": "list = LIU_POSITIVE_OPINION_WORDS_EN()\n",
- "LN_HALF": "LN_HALF\n",
- "LN_PI": "LN_PI\n",
- "LN_SQRT_TWO_PI": "LN_SQRT_TWO_PI\n",
- "LN_TWO_PI": "LN_TWO_PI\n",
- "LN2": "LN2\n",
- "LN10": "LN10\n",
- "LOG2E": "LOG2E\n",
- "LOG10E": "LOG10E\n",
- "logspace": "arr = logspace( 0, 2, 6 )\n",
- "lowercase": "out = lowercase( 'bEEp' )\n",
- "lowercaseKeys": "obj = { 'A': 1, 'B': 2 };\nout = lowercaseKeys( obj )\n",
- "lowess": "x = new Float64Array( 100 );\ny = new Float64Array( x.length );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = i;\n y[ i ] = ( 0.5*i ) + ( 10.0*base.random.randn() );\n}\nout = lowess( x, y );\nyhat = out.y;\nh = Plot( [ x, x ], [ y, yhat ] );\nh.lineStyle = [ 'none', '-' ];\nh.symbols = [ 'closed-circle', 'none' ];\nh.view( 'window' );\n",
- "lpad": "out = lpad( 'a', 5 )\nout = lpad( 'beep', 10, 'b' )\nout = lpad( 'boop', 12, 'beep' )\n",
- "ltrim": "out = ltrim( ' \\r\\n\\t Beep \\t\\t\\n ' )\n",
- "MALE_FIRST_NAMES_EN": "list = MALE_FIRST_NAMES_EN()\n",
- "mapFun": "function fcn( i ) { return i; };\narr = mapFun( fcn, 5 )\n",
- "mapFunAsync": "\n// Basic usage:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nmapFunAsync( fcn, 10, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nopts = { 'limit': 2 };\nmapFunAsync( fcn, 10, opts, done )\n\n// Sequential invocation:\nfunction fcn( i, next ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n next( null, i );\n }\n};\nfunction done( error, arr ) {\n if ( error ) {\n throw error;\n }\n console.log( arr );\n};\nopts = { 'series': true };\nmapFunAsync( fcn, 10, opts, done )\n",
- "mapKeys": "function transform( key, value ) { return key + value; };\nobj = { 'a': 1, 'b': 2 };\nout = mapKeys( obj, transform )\n",
- "mapKeysAsync": "\n// Basic usage:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nobj = { 'a': 1, 'b': 2 };\nmapKeysAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nopts = { 'limit': 2 };\nobj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( key, value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nopts = { 'series': true };\nobj = { 'a': 1, 'b': 2, 'c': 3 };\nmapKeysAsync( obj, opts, transform, done )\n",
- "mapValues": "function transform( value, key ) { return key + value; };\nobj = { 'a': 1, 'b': 2 };\nout = mapValues( obj, transform )\n",
- "mapValuesAsync": "\n// Basic usage:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nobj = { 'a': 1, 'b': 2 };\nmapValuesAsync( obj, transform, done )\n\n// Limit number of concurrent invocations:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nopts = { 'limit': 2 };\nobj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n\n// Process sequentially:\nfunction transform( value, key, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n next( null, key+':'+value );\n }\n};\nfunction done( error, out ) {\n if ( error ) {\n throw error;\n }\n console.log( out );\n};\nopts = { 'series': true };\nobj = { 'a': 1, 'b': 2, 'c': 3 };\nmapValuesAsync( obj, opts, transform, done )\n",
- "MAX_ARRAY_LENGTH": "MAX_ARRAY_LENGTH\n",
- "MAX_TYPED_ARRAY_LENGTH": "MAX_TYPED_ARRAY_LENGTH\n",
- "memoize": "function factorial( n ) {\n var prod;\n var i;\n prod = 1;\n for ( i = n; i > 1; i-- ) {\n prod *= i;\n }\n return prod;\n};\nmemoized = memoize( factorial );\nv = memoized( 5 )\nv = memoized( 5 )\n",
- "merge": "target = { 'a': 'beep' };\nsource = { 'a': 'boop', 'b': 'bap' };\nout = merge( target, source )\nbool = ( out === target )\n",
- "MILLISECONDS_IN_DAY": "days = 3.14;\nms = days * MILLISECONDS_IN_DAY\n",
- "MILLISECONDS_IN_HOUR": "hrs = 3.14;\nms = hrs * MILLISECONDS_IN_HOUR\n",
- "MILLISECONDS_IN_MINUTE": "mins = 3.14;\nms = mins * MILLISECONDS_IN_MINUTE\n",
- "MILLISECONDS_IN_SECOND": "secs = 3.14;\nms = secs * MILLISECONDS_IN_SECOND\n",
- "MILLISECONDS_IN_WEEK": "weeks = 3.14;\nms = weeks * MILLISECONDS_IN_WEEK\n",
- "MINARD_NAPOLEONS_MARCH": "data = MINARD_NAPOLEONS_MARCH();\narmy = data.army\ncities = data.cities\nlabels = data.labels\nriver = data.river\nt = data.temperature\n",
- "MINUTES_IN_DAY": "days = 3.14;\nmins = days * MINUTES_IN_DAY\n",
- "MINUTES_IN_HOUR": "hrs = 3.14;\nmins = hrs * MINUTES_IN_HOUR\n",
- "MINUTES_IN_WEEK": "wks = 3.14;\nmins = wks * MINUTES_IN_WEEK\n",
- "minutesInMonth": "num = minutesInMonth()\nnum = minutesInMonth( 2 )\nnum = minutesInMonth( 2, 2016 )\nnum = minutesInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = minutesInMonth( 'feb', 2016 )\nnum = minutesInMonth( 'february', 2016 )\n",
- "minutesInYear": "num = minutesInYear()\nnum = minutesInYear( 2016 )\nnum = minutesInYear( 2017 )\n",
- "MOBY_DICK": "data = MOBY_DICK()\n",
- "MONTH_NAMES_EN": "list = MONTH_NAMES_EN()\n",
- "MONTHS_IN_YEAR": "yrs = 3.14;\nmons = yrs * MONTHS_IN_YEAR\n",
- "moveProperty": "obj1 = { 'a': 'b' };\nobj2 = {};\nbool = moveProperty( obj1, 'a', obj2 )\nbool = moveProperty( obj1, 'c', obj2 )\n",
- "namedtypedtuple": "opts = {};\nopts.name = 'Point';\nfactory = namedtypedtuple( [ 'x', 'y' ], opts );\ntuple = factory();\n",
- "nativeClass": "str = nativeClass( 'a' )\nstr = nativeClass( 5 )\nfunction Beep(){};\nstr = nativeClass( new Beep() )\n",
- "ndarray": "ctor = ndarray( 'generic', 2 )\n\n// To create a new instance...\nb = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nd = [ 2, 2 ]; // shape\ns = [ 2, 1 ]; // strides\no = 0; // index offset\narr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nv = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n",
- "ndarrayCastingModes": "out = ndarrayCastingModes()\n",
- "ndarrayDataTypes": "out = ndarrayDataTypes()\n",
- "ndarrayIndexModes": "out = ndarrayIndexModes()\n",
- "ndarrayMemoized": "ctor = ndarrayMemoized( 'generic', 2 )\nf = ndarrayMemoized( 'generic', 2 )\nbool = ( f === ctor )\n\n// To create a new instance...\nb = [ 1.0, 2.0, 3.0, 4.0 ]; // underlying data buffer\nd = [ 2, 2 ]; // shape\ns = [ 2, 1 ]; // strides\no = 0; // index offset\narr = ctor( b, d, s, o, 'row-major' )\n\n// Get an element using subscripts:\nv = arr.get( 1, 1 )\n\n// Get an element using a linear index:\nv = arr.iget( 3 )\n\n// Set an element using subscripts:\narr.set( 1, 1, 40.0 );\narr.get( 1, 1 )\n\n// Set an element using a linear index:\narr.iset( 3, 99.0 );\narr.get( 1, 1 )\n",
- "ndarrayMinDataType": "dt = ndarrayMinDataType( 3.141592653589793 )\ndt = ndarrayMinDataType( 3 )\ndt = ndarrayMinDataType( -3 )\ndt = ndarrayMinDataType( '-3' )\n",
- "ndarrayNextDataType": "out = ndarrayNextDataType( 'float32' )\n",
- "ndarrayOrders": "out = ndarrayOrders()\n",
- "ndarrayPromotionRules": "out = ndarrayPromotionRules( 'float32', 'int32' )\n",
- "ndarraySafeCasts": "out = ndarraySafeCasts( 'float32' )\n",
- "ndarraySameKindCasts": "out = ndarraySameKindCasts( 'float32' )\n",
- "NIGHTINGALES_ROSE": "data = NIGHTINGALES_ROSE()\n",
- "NINF": "NINF\n",
- "NODE_VERSION": "NODE_VERSION\n",
- "none": "arr = [ 0, 0, 0, 0, 0 ];\nbool = none( arr )\n",
- "noneBy": "function negative( v ) { return ( v < 0 ); };\narr = [ 1, 2, 3, 4 ];\nbool = noneBy( arr, negative )\n",
- "noneByAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\nnoneByAsync( arr, opts, predicate, done )\n",
- "noneByRight": "function positive( v ) { return ( v > 0 ); };\narr = [ -1, -2, -3, -4 ];\nbool = noneByRight( arr, positive )\n",
- "noneByRightAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\nnoneByRightAsync( arr, opts, predicate, done )\n",
- "nonEnumerableProperties": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nprops = nonEnumerableProperties( obj )\n",
- "nonEnumerablePropertiesIn": "props = nonEnumerablePropertiesIn( [] )\n",
- "nonEnumerablePropertyNames": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nkeys = nonEnumerablePropertyNames( obj )\n",
- "nonEnumerablePropertyNamesIn": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nkeys = nonEnumerablePropertyNamesIn( obj )\n",
- "nonEnumerablePropertySymbols": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = nonEnumerablePropertySymbols( obj )\n",
- "nonEnumerablePropertySymbolsIn": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = nonEnumerablePropertySymbolsIn( obj )\n",
- "noop": "noop();\n",
- "now": "ts = now()\n",
- "NUM_CPUS": "NUM_CPUS\n",
- "Number": "v = new Number( 5 )\n",
- "objectEntries": "obj = { 'beep': 'boop', 'foo': 'bar' };\nentries = objectEntries( obj )\n",
- "objectEntriesIn": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nentries = objectEntriesIn( obj )\n",
- "objectFromEntries": "entries = [ [ 'beep', 'boop' ], [ 'foo', 'bar' ] ];\nobj = objectFromEntries( entries )\n",
- "objectInverse": "\n// Basic usage:\nobj = { 'a': 'beep', 'b': 'boop' };\nout = objectInverse( obj )\n\n// Duplicate values:\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverse( obj )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverse( obj, { 'duplicates': false } )\n",
- "objectInverseBy": "\n// Basic usage:\nfunction transform( key, value ) { return key + value; };\nobj = { 'a': 'beep', 'b': 'boop' };\nout = objectInverseBy( obj, transform )\n\n// Duplicate values:\nfunction transform( key, value ) { return value; };\nobj = { 'a': 'beep', 'b': 'beep' };\nout = objectInverseBy( obj, transform )\n\n// Override duplicate values:\nobj = {};\nobj.a = 'beep';\nobj.b = 'boop';\nobj.c = 'beep';\nout = objectInverseBy( obj, { 'duplicates': false }, transform )\n",
- "objectKeys": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nkeys = objectKeys( obj )\n",
- "objectValues": "obj = { 'beep': 'boop', 'foo': 'bar' };\nvals = objectValues( obj )\n",
- "objectValuesIn": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nvalues = objectValuesIn( obj )\n",
- "omit": "obj1 = { 'a': 1, 'b': 2 };\nobj2 = omit( obj1, 'b' )\n",
- "omitBy": "function predicate( key, value ) { return ( value > 1 ); };\nobj1 = { 'a': 1, 'b': 2 };\nobj2 = omitBy( obj1, predicate )\n",
- "openURL": "out = openURL( 'https://google.com' );\n",
- "PACE_BOSTON_HOUSE_PRICES": "data = PACE_BOSTON_HOUSE_PRICES()\n",
- "pad": "\n// Standard usage:\nout = pad( 'a', 5 )\n\n// Left pad:\nout = pad( 'a', 10, { 'lpad': 'b' })\n\n// Right pad:\nout = pad( 'a', 12, { 'rpad': 'b' })\n\n// Center an input string:\nopts = { 'lpad': 'a', 'rpad': 'c' };\nout = pad( 'b', 11, opts )\n\n// Left center:\nopts.centerRight = false;\nout = pad( 'b', 10, opts )\n\n// Right center:\nopts.centerRight = true;\nout = pad( 'b', 10, opts )\n\n// Output string always length `len`:\nopts = { 'lpad': 'boop', 'rpad': 'woot' };\nout = pad( 'beep', 10, opts )\n\n// Pad right, trim right:\nout = pad( 'beep', 2 )\n\n// Pad left, trim left:\nopts = { 'lpad': 'b' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both:\nopts = { 'lpad': '@', 'rpad': '!' };\nout = pad( 'beep', 2, opts )\n\n// Pad both, trim both starting from left:\nout = pad( 'abcdef', 3, opts )\n\n// Pad both, trim both starting from right:\nopts.centerRight = true;\nout = pad( 'abcdef', 3, opts )\n",
- "papply": "function add( x, y ) { return x + y; };\nadd2 = papply( add, 2 );\nsum = add2( 3 )\n",
- "papplyRight": "function say( text, name ) { return text + ', ' + name + '.'; };\ntoGrace = papplyRight( say, 'Grace Hopper' );\nstr = toGrace( 'Hello' )\nstr = toGrace( 'Thank you' )\n",
- "parallel": "function done( error ) { if ( error ) { throw error; } };\nfiles = [ './a.js', './b.js' ];\nparallel( files, done );\n\n// Specify the number of workers:\nopts = { 'workers': 8 };\nparallel( files, opts, done );\n",
- "parseJSON": "obj = parseJSON( '{\"beep\":\"boop\"}' )\n\n// Provide a reviver:\nfunction reviver( key, value ) {\n if ( key === '' ) { return value; }\n if ( key === 'beep' ) { return value; }\n};\nstr = '{\"beep\":\"boop\",\"a\":\"b\"}';\nout = parseJSON( str, reviver )\n",
- "PATH_DELIMITER": "PATH_DELIMITER\n\n// POSIX environment:\npath = '/usr/bin:/bin:/usr/sbin';\nparts = path.split( PATH_DELIMITER )\n\n// Windows environment:\npath = 'C:\\\\Windows\\\\system32;C:\\\\Windows';\nparts = path.split( PATH_DELIMITER )\n",
- "PATH_DELIMITER_POSIX": "PATH_DELIMITER_POSIX\nPATH = '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin';\npaths = PATH.split( PATH_DELIMITER_POSIX )\n",
- "PATH_DELIMITER_WIN32": "PATH_DELIMITER_WIN32\nPATH = 'C:\\\\Windows\\\\system32;C:\\\\Windows;C:\\\\Program Files\\\\node\\\\';\npaths = PATH.split( PATH_DELIMITER_WIN32 )\n",
- "PATH_SEP": "PATH_SEP\n\n// Windows environment:\nparts = 'foo\\\\bar\\\\baz'.split( PATH_SEP )\n\n// POSIX environment:\nparts = 'foo/bar/baz'.split( PATH_SEP )\n",
- "PATH_SEP_POSIX": "PATH_SEP_POSIX\nparts = 'foo/bar/baz'.split( PATH_SEP_POSIX )\n",
- "PATH_SEP_WIN32": "PATH_SEP_WIN32\nparts = 'foo\\\\bar\\\\baz'.split( PATH_SEP_WIN32 )\n",
- "pcorrtest": "rho = 0.5;\nx = new Array( 300 );\ny = new Array( 300 );\nfor ( var i = 0; i < 300; i++ ) {\n x[ i ] = base.random.normal( 0.0, 1.0 );\n y[ i ] = ( rho * x[ i ] ) + base.random.normal( 0.0,\n base.sqrt( 1.0 - (rho*rho) ) );\n}\nout = pcorrtest( x, y )\n\n// Print output:\ntable = out.print()\n",
- "percentEncode": "out = percentEncode( '☃' )\n",
- "PHI": "PHI\n",
- "PI": "PI\n",
- "PI_SQUARED": "PI_SQUARED\n",
- "pick": "obj1 = { 'a': 1, 'b': 2 };\nobj2 = pick( obj1, 'b' )\n",
- "pickBy": "function predicate( key, value ) {\n return ( value > 1 );\n};\nobj1 = { 'a': 1, 'b': 2 };\nobj2 = pickBy( obj1, predicate )\n",
- "PINF": "PINF\n",
- "PLATFORM": "PLATFORM\n",
- "plot": "plot = plot()\n\n// Provide plot data at instantiation:\nx = [[0.10, 0.20, 0.30]];\ny = [[0.52, 0.79, 0.64]];\nplot = plot( x, y )\n",
- "Plot": "plot = Plot()\n\n// Provide plot data at instantiation:\nx = [[0.10, 0.20, 0.30]];\ny = [[0.52, 0.79, 0.64]];\nplot = Plot( x, y )\n",
- "pluck": "arr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nout = pluck( arr, 'a' )\narr = [\n { 'a': 1, 'b': 2 },\n { 'a': 0.5, 'b': 3 }\n];\nout = pluck( arr, 'a', { 'copy': false } )\nbool = ( arr[ 0 ] === out[ 0 ] )\n",
- "pop": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nout = pop( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = pop( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = pop( arr )\n",
- "prepend": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = prepend( arr, [ 6.0, 7.0 ] )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = prepend( arr, [ 3.0, 4.0 ] )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = prepend( arr, [ 2.0, 3.0 ] )\n",
- "properties": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nprops = properties( obj )\n",
- "propertiesIn": "props = propertiesIn( [] )\n",
- "propertyDescriptor": "obj = { 'a': 'b' };\ndesc = propertyDescriptor( obj, 'a' )\n",
- "propertyDescriptorIn": "obj = { 'a': 'b' };\ndesc = propertyDescriptorIn( obj, 'a' )\n",
- "propertyDescriptors": "obj = { 'a': 'b' };\ndesc = propertyDescriptors( obj )\n",
- "propertyDescriptorsIn": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\ndesc = propertyDescriptorsIn( obj )\n",
- "propertyNames": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nkeys = propertyNames( obj )\n",
- "propertyNamesIn": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nkeys = propertyNamesIn( obj )\n",
- "propertySymbols": "s = propertySymbols( {} )\n",
- "propertySymbolsIn": "s = propertySymbolsIn( [] )\n",
- "Proxy": "function get( obj, prop ) { return obj[ prop ] * 2.0 };\nh = { 'get': get };\np = new Proxy( {}, h );\np.a = 3.14;\np.a\n",
- "push": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = push( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = push( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 0 };\narr = push( arr, 1.0, 2.0 )\n",
- "quarterOfYear": "q = quarterOfYear( new Date() )\nq = quarterOfYear( 4 )\nq = quarterOfYear( 'June' )\n\n// Other ways to supply month:\nq = quarterOfYear( 'April' )\nq = quarterOfYear( 'apr' )\n",
- "random.iterators.arcsine": "it = random.iterators.arcsine( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.bernoulli": "it = random.iterators.bernoulli( 0.3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.beta": "it = random.iterators.beta( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.betaprime": "it = random.iterators.betaprime( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.binomial": "it = random.iterators.binomial( 10, 0.3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.boxMuller": "it = random.iterators.boxMuller();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.cauchy": "it = random.iterators.cauchy( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.chi": "it = random.iterators.chi( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.chisquare": "it = random.iterators.chisquare( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.cosine": "it = random.iterators.cosine( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.discreteUniform": "it = random.iterators.discreteUniform( 0, 3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.erlang": "it = random.iterators.erlang( 1, 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.exponential": "it = random.iterators.exponential( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.f": "it = random.iterators.f( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.frechet": "it = random.iterators.frechet( 1.0, 1.0, 0.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.gamma": "it = random.iterators.gamma( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.geometric": "it = random.iterators.geometric( 0.3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.gumbel": "it = random.iterators.gumbel( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.hypergeometric": "it = random.iterators.hypergeometric( 20, 10, 7 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.improvedZiggurat": "it = random.iterators.improvedZiggurat();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.invgamma": "it = random.iterators.invgamma( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.kumaraswamy": "it = random.iterators.kumaraswamy( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.laplace": "it = random.iterators.laplace( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.levy": "it = random.iterators.levy( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.logistic": "it = random.iterators.logistic( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.lognormal": "it = random.iterators.lognormal( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.minstd": "it = random.iterators.minstd();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.minstdShuffle": "it = random.iterators.minstdShuffle();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.mt19937": "it = random.iterators.mt19937();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.negativeBinomial": "it = random.iterators.negativeBinomial( 10, 0.3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.normal": "it = random.iterators.normal( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.pareto1": "it = random.iterators.pareto1( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.poisson": "it = random.iterators.poisson( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.randi": "it = random.iterators.randi();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.randn": "it = random.iterators.randn();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.randu": "it = random.iterators.randu();\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.rayleigh": "it = random.iterators.rayleigh( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.t": "it = random.iterators.t( 1.5 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.triangular": "it = random.iterators.triangular( 0.0, 1.0, 0.3 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.uniform": "it = random.iterators.uniform( 0.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.iterators.weibull": "it = random.iterators.weibull( 1.0, 1.0 );\nr = it.next().value\nr = it.next().value\n",
- "random.streams.arcsine": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.arcsine( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.bernoulli": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.bernoulli( 0.5, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.beta": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.beta( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.betaprime": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.betaprime( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.binomial": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.binomial( 20, 0.5, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.boxMuller": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.boxMuller( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.cauchy": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.cauchy( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.chi": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.chi( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.chisquare": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.chisquare( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.cosine": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.cosine( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.discreteUniform": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.discreteUniform( 2, 5, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.erlang": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.erlang( 2, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.exponential": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.exponential( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.f": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.f( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.gamma": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.gamma( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.geometric": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.geometric( 0.5, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.gumbel": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.gumbel( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.improvedZiggurat": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.improvedZiggurat( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.invgamma": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.invgamma( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.kumaraswamy": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.kumaraswamy( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.laplace": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.laplace( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.levy": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.levy( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.logistic": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.logistic( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.lognormal": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.lognormal( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.minstd": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.minstd( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.minstdShuffle": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.minstdShuffle( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.mt19937": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.mt19937( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.negativeBinomial": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.negativeBinomial( 20.0, 0.5, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.normal": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.normal( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.pareto1": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.pareto1( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.poisson": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.poisson( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.randi": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.randi( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.randn": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.randn( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.randu": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.randu( opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.rayleigh": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.rayleigh( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.t": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.t( 3.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.uniform": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.uniform( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "random.streams.weibull": "function fcn( chunk ) { console.log( chunk.toString() ); };\nopts = { 'iter': 10 };\ns = random.streams.weibull( 2.0, 5.0, opts );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "ranks": "arr = [ 1.1, 2.0, 3.5, 0.0, 2.4 ] ;\nout = ranks( arr )\n\n// Ties are averaged:\narr = [ 2, 2, 1, 4, 3 ];\nout = ranks( arr )\n\n// Missing values are placed last:\narr = [ null, 2, 2, 1, 4, 3, NaN, NaN ];\nout = ranks( arr )\n",
- "RE_BASENAME": "base = RE_BASENAME.exec( '/foo/bar/index.js' )[ 1 ]\n",
- "RE_BASENAME_POSIX": "base = RE_BASENAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '.' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( './' )[ 1 ]\nbase = RE_BASENAME_POSIX.exec( '' )[ 1 ]\n",
- "RE_BASENAME_WINDOWS": "base = RE_BASENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'foo\\\\bar\\\\file' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( 'index.js' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '.' )[ 1 ]\nbase = RE_BASENAME_WINDOWS.exec( '' )[ 1 ]\n",
- "RE_COLOR_HEXADECIMAL": "bool = RE_COLOR_HEXADECIMAL.test( 'ffffff' )\nbool = RE_COLOR_HEXADECIMAL.test( '000' )\nbool = RE_COLOR_HEXADECIMAL.test( 'beep' )\n",
- "RE_DECIMAL_NUMBER": "bool = RE_DECIMAL_NUMBER.test( '1.234' )\nbool = RE_DECIMAL_NUMBER.test( '-1.234' )\nbool = RE_DECIMAL_NUMBER.test( '0.0' )\nbool = RE_DECIMAL_NUMBER.test( '.0' )\nbool = RE_DECIMAL_NUMBER.test( '0' )\nbool = RE_DECIMAL_NUMBER.test( 'beep' )\n\n// Create a RegExp to capture all decimal numbers:\nre = new RegExp( RE_DECIMAL_NUMBER.source, 'g' );\nstr = '1.234 5.6, 7.8';\nout = str.match( re )\n",
- "RE_DIRNAME": "dir = RE_DIRNAME.exec( '/foo/bar/index.js' )[ 1 ]\n",
- "RE_DIRNAME_POSIX": "dir = RE_DIRNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '.' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( './' )[ 1 ]\ndir = RE_DIRNAME_POSIX.exec( '' )[ 1 ]\n",
- "RE_DIRNAME_WINDOWS": "dir = RE_DIRNAME_WINDOWS.exec( 'foo\\\\bar\\\\index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( 'index.js' )[ 1 ]\ndir = RE_DIRNAME_WINDOWS.exec( '' )[ 1 ]\n",
- "RE_EOL": "bool = RE_EOL.test( '\\n' )\nbool = RE_EOL.test( '\\r\\n' )\nbool = RE_EOL.test( '\\\\r\\\\n' )\n",
- "RE_EXTENDED_LENGTH_PATH": "path = '\\\\\\\\?\\\\C:\\\\foo\\\\bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '\\\\\\\\?\\\\UNC\\\\server\\\\share';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = 'C:\\\\foo\\\\bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/c/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\npath = '/foo/bar';\nbool = RE_EXTENDED_LENGTH_PATH.test( path )\n",
- "RE_EXTNAME": "dir = RE_EXTNAME.exec( '/foo/bar/index.js' )[ 1 ]\n",
- "RE_EXTNAME_POSIX": "ext = RE_EXTNAME_POSIX.exec( '/foo/bar/index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './foo/bar/.gitignore' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'foo/file.pdf' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '/foo/bar/file' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '.' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( './' )[ 1 ]\next = RE_EXTNAME_POSIX.exec( '' )[ 1 ]\n",
- "RE_EXTNAME_WINDOWS": "ext = RE_EXTNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\.gitignore' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'foo\\\\file.pdf' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'beep\\\\boop.' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( 'index.js' )[ 1 ]\next = RE_EXTNAME_WINDOWS.exec( '' )[ 1 ]\n",
- "RE_FILENAME": "f = '/foo/bar/index.js';\nparts = RE_FILENAME.exec( f ).slice()\n",
- "RE_FILENAME_POSIX": "parts = RE_FILENAME_POSIX.exec( '/foo/bar/index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( './foo/bar/.gitignore' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'foo/file.pdf' ).slice()\nparts = RE_FILENAME_POSIX.exec( '/foo/bar/file' ).slice()\nparts = RE_FILENAME_POSIX.exec( 'index.js' ).slice()\nparts = RE_FILENAME_POSIX.exec( '.' ).slice()\nparts = RE_FILENAME_POSIX.exec( './' ).slice()\nparts = RE_FILENAME_POSIX.exec( '' ).slice()\n",
- "RE_FILENAME_WINDOWS": "parts = RE_FILENAME_WINDOWS.exec( 'C:\\\\foo\\\\bar\\\\index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\.gitignore' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'foo\\\\file.pdf' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '\\\\foo\\\\bar\\\\file' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( 'index.js' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '.' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( './' ).slice()\nparts = RE_FILENAME_WINDOWS.exec( '' ).slice()\n",
- "RE_FUNCTION_NAME": "function beep() { return 'boop'; };\nname = RE_FUNCTION_NAME.exec( beep.toString() )[ 1 ]\nname = RE_FUNCTION_NAME.exec( function () {} )[ 1 ]\n",
- "RE_NATIVE_FUNCTION": "bool = RE_NATIVE_FUNCTION.test( Date.toString() )\nbool = RE_NATIVE_FUNCTION.test( (function noop() {}).toString() )\n",
- "RE_REGEXP": "bool = RE_REGEXP.test( '/^beep$/' )\nbool = RE_REGEXP.test( '/boop' )\n\n// Escape regular expression strings:\nbool = RE_REGEXP.test( '/^\\/([^\\/]+)\\/(.*)$/' )\nbool = RE_REGEXP.test( '/^\\\\/([^\\\\/]+)\\\\/(.*)$/' )\n",
- "RE_UNC_PATH": "path = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:b';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz::b';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\\\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = 'beep boop \\\\\\\\server\\\\share';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz::';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\baz:a:b:c';\nbool = RE_UNC_PATH.test( path )\npath = '\\\\\\\\server\\\\share\\\\foo\\\\bar\\\\';\nbool = RE_UNC_PATH.test( path )\npath = '//server/share';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = 'foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = './foo/bar';\nbool = RE_UNC_PATH.test( path )\npath = '/foo/../bar';\nbool = RE_UNC_PATH.test( path )\n",
- "RE_UTF16_SURROGATE_PAIR": "bool = RE_UTF16_SURROGATE_PAIR.test( 'abc\\uD800\\uDC00def' )\nbool = RE_UTF16_SURROGATE_PAIR.test( 'abcdef' )\n",
- "RE_UTF16_UNPAIRED_SURROGATE": "bool = RE_UTF16_UNPAIRED_SURROGATE.test( 'abc' )\nbool = RE_UTF16_UNPAIRED_SURROGATE.test( '\\uD800' )\n",
- "RE_WHITESPACE": "bool = RE_WHITESPACE.test( '\\n' )\nbool = RE_WHITESPACE.test( ' ' )\nbool = RE_WHITESPACE.test( 'a' )\n",
- "readDir": "function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadDir( './beep/boop', onRead );\n",
- "readFile": "function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadFile( './beep/boop.js', onRead );\n",
- "readFileList": "function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nfilepaths = [ './beep/boop.txt', './foo/bar.txt' ];\nreadFileList( filepaths, onRead );\n",
- "readJSON": "function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadJSON( './beep/boop.json', onRead );\n",
- "readWASM": "function onRead( error, data ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( data );\n }\n};\nreadWASM( './beep/boop.wasm', onRead );\n",
- "real": "z = new Complex128( 5.0, 3.0 );\nre = real( z )\n",
- "realmax": "m = realmax( 'float16' )\nm = realmax( 'float32' )\n",
- "realmin": "m = realmin( 'float16' )\nm = realmin( 'float32' )\n",
- "reduce": "function sum( acc, v ) { return acc + v; };\narr = [ 1.0, 2.0, 3.0 ];\nout = reduce( arr, 0, sum )\n",
- "reduceAsync": "\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\narr = [ 3000, 2500, 1000 ];\nacc = { 'sum': 0 };\nreduceAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nacc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nopts = { 'series': false };\narr = [ 3000, 2500, 1000 ];\nacc = { 'sum': 0 };\nreduceAsync( arr, acc, opts, fcn, done )\n",
- "reduceRight": "function sum( acc, v ) {\n console.log( '%s: %d', acc, v );\n return acc + v;\n};\narr = [ 1.0, 2.0, 3.0 ];\nout = reduceRight( arr, 0, sum );\nout\n",
- "reduceRightAsync": "\n// Basic usage:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\narr = [ 1000, 2500, 3000 ];\nacc = { 'sum': 0 };\nreduceRightAsync( arr, acc, fcn, done )\n\n// Limit number of concurrent invocations:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\nacc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n\n// Process concurrently:\nfunction fcn( acc, value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n acc.sum += value;\n next( null, acc );\n }\n};\nfunction done( error, acc ) {\n if ( error ) {\n throw error;\n }\n console.log( acc.sum );\n};\nopts = { 'series': false };\narr = [ 1000, 2500, 3000 ];\nacc = { 'sum': 0 };\nreduceRightAsync( arr, acc, opts, fcn, done )\n",
- "reFromString": "re = reFromString( '/beep/' )\nre = reFromString( '/beep' )\n",
- "reim": "z = new Complex128( 5.0, 3.0 );\nout = reim( z )\n",
- "removeFirst": "out = removeFirst( 'beep' )\nout = removeFirst( 'Boop' )\n",
- "removeLast": "out = removeLast( 'beep' )\nout = removeLast( 'Boop' )\n",
- "removePunctuation": "str = 'Sun Tzu said: \"A leader leads by example not by force.\"';\nout = removePunctuation( str )\nstr = 'This function removes these characters: `{}[]:,!/<>().;~|?\\'\"';\nout = removePunctuation( str )\n",
- "removeUTF8BOM": "out = removeUTF8BOM( '\\ufeffbeep' )\n",
- "removeWords": "out = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ] )\n\n// Case-insensitive:\nout = removeWords( 'beep boop Foo bar', [ 'boop', 'foo' ], true )\n",
- "rename": "function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nrename( './beep/boop.txt', './beep/foo.txt', done );\n",
- "reorderArguments": "function foo( a, b, c ) { return [ a, b, c ]; };\nbar = reorderArguments( foo, [ 2, 0, 1 ] );\nout = bar( 1, 2, 3 )\n",
- "repeat": "out = repeat( 'a', 5 )\nout = repeat( '', 100 )\nout = repeat( 'beep', 0 )\n",
- "replace": "\n// Standard usage:\nout = replace( 'beep', 'e', 'o' )\n\n// Replacer function:\nfunction replacer( match, p1 ) { return '/'+p1+'/'; };\nstr = 'Oranges and lemons';\nout = replace( str, /([^\\s]+)/gi, replacer )\n\n// Replace only first match:\nout = replace( 'beep', /e/, 'o' )\n",
- "rescape": "str = rescape( '[A-Z]*' )\n",
- "resolveParentPath": "function onPath( error, path ) {\n if ( error ) {\n console.error( error.message );\n } else {\n console.log( path );\n }\n};\nresolveParentPath( 'package.json', onPath );\n",
- "reverseArguments": "function foo( a, b, c ) { return [ a, b, c ]; };\nbar = reverseArguments( foo );\nout = bar( 1, 2, 3 )\n",
- "reverseString": "out = reverseString( 'foo' )\nout = reverseString( 'abcdef' )\n",
- "reviveBasePRNG": "str = JSON.stringify( base.random.mt19937 );\nr = parseJSON( str, reviveBasePRNG )\n",
- "reviveBuffer": "str = '{\"type\":\"Buffer\",\"data\":[5,3]}';\nbuf = parseJSON( str, reviveBuffer )\n",
- "reviveComplex": "str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nz = parseJSON( str, reviveComplex )\n",
- "reviveComplex64": "str = '{\"type\":\"Complex64\",\"re\":5,\"im\":3}';\nz = parseJSON( str, reviveComplex64 )\n",
- "reviveComplex128": "str = '{\"type\":\"Complex128\",\"re\":5,\"im\":3}';\nz = parseJSON( str, reviveComplex128 )\n",
- "reviveError": "str = '{\"type\":\"TypeError\",\"message\":\"beep\"}';\nerr = JSON.parse( str, reviveError )\n",
- "reviveTypedArray": "str = '{\"type\":\"Float64Array\",\"data\":[5,3]}';\narr = parseJSON( str, reviveTypedArray )\n",
- "rpad": "out = rpad( 'a', 5 )\nout = rpad( 'beep', 10, 'p' )\nout = rpad( 'beep', 12, 'boop' )\n",
- "rtrim": "out = rtrim( ' \\t\\t\\n Beep \\r\\n\\t ' )\n",
- "safeintmax": "m = safeintmax( 'float16' )\nm = safeintmax( 'float32' )\n",
- "safeintmin": "m = safeintmin( 'float16' )\nm = safeintmin( 'float32' )\n",
- "sample": "out = sample( 'abc' )\nout = sample( [ 3, 6, 9 ] )\nbool = ( out.length === 3 )\nout = sample( [ 3, null, NaN, 'abc', function(){} ] )\n\n// Set sample size:\nout = sample( [ 3, 6, 9 ], { 'size': 10 })\nout = sample( [ 0, 1 ], { 'size': 20 })\n\n// Draw without replacement:\nout = sample( [ 1, 2, 3, 4, 5, 6 ], { 'replace': false, 'size': 3 })\nout = sample( [ 0, 1 ], { 'replace': false })\n\n// Assigning non-uniform element probabilities:\nx = [ 1, 2, 3, 4, 5, 6 ];\nprobs = [ 0.1, 0.1, 0.1, 0.1, 0.1, 0.5 ];\nout = sample( x, { 'probs': probs })\nout = sample( x, { 'probs': probs, 'size': 3, 'replace': false })\n",
- "SAVOY_STOPWORDS_FIN": "list = SAVOY_STOPWORDS_FIN()\n",
- "SAVOY_STOPWORDS_FR": "list = SAVOY_STOPWORDS_FR()\n",
- "SAVOY_STOPWORDS_GER": "list = SAVOY_STOPWORDS_GER()\n",
- "SAVOY_STOPWORDS_IT": "list = SAVOY_STOPWORDS_IT()\n",
- "SAVOY_STOPWORDS_POR": "list = SAVOY_STOPWORDS_POR()\n",
- "SAVOY_STOPWORDS_SP": "list = SAVOY_STOPWORDS_SP()\n",
- "SAVOY_STOPWORDS_SWE": "list = SAVOY_STOPWORDS_SWE()\n",
- "SECONDS_IN_DAY": "days = 3.14;\nsecs = days * SECONDS_IN_DAY\n",
- "SECONDS_IN_HOUR": "hrs = 3.14;\nsecs = hrs * SECONDS_IN_HOUR\n",
- "SECONDS_IN_MINUTE": "mins = 3.14;\nsecs = mins * SECONDS_IN_MINUTE\n",
- "SECONDS_IN_WEEK": "wks = 3.14;\nsecs = wks * SECONDS_IN_WEEK\n",
- "secondsInMonth": "num = secondsInMonth()\nnum = secondsInMonth( 2 )\nnum = secondsInMonth( 2, 2016 )\nnum = secondsInMonth( 2, 2017 )\n\n// Other ways to supply month:\nnum = secondsInMonth( 'feb', 2016 )\nnum = secondsInMonth( 'february', 2016 )\n",
- "secondsInYear": "num = secondsInYear()\nnum = secondsInYear( 2016 )\nnum = secondsInYear( 2017 )\n",
- "setNonEnumerableProperty": "obj = {};\nsetNonEnumerableProperty( obj, 'foo', 'bar' );\nobj.foo\nobjectKeys( obj )\n",
- "setNonEnumerableReadOnly": "obj = {};\nsetNonEnumerableReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n",
- "setNonEnumerableReadOnlyAccessor": "obj = {};\nfunction getter() { return 'bar'; };\nsetNonEnumerableReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n",
- "setNonEnumerableReadWriteAccessor": "obj = {};\nname = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetNonEnumerableReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n",
- "setNonEnumerableWriteOnlyAccessor": "obj = {};\nval = '';\nfunction setter( v ) { val = v; };\nsetNonEnumerableWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n",
- "setReadOnly": "obj = {};\nsetReadOnly( obj, 'foo', 'bar' );\nobj.foo = 'boop';\nobj\n",
- "setReadOnlyAccessor": "obj = {};\nfunction getter() { return 'bar'; };\nsetReadOnlyAccessor( obj, 'foo', getter );\nobj.foo\n",
- "setReadWriteAccessor": "obj = {};\nname = 'bar';\nfunction getter() { return name + ' foo'; };\nfunction setter( v ) { name = v; };\nsetReadWriteAccessor( obj, 'foo', getter, setter );\nobj.foo\nobj.foo = 'beep';\nobj.foo\n",
- "setWriteOnlyAccessor": "obj = {};\nval = '';\nfunction setter( v ) { val = v; };\nsetWriteOnlyAccessor( obj, 'foo', setter );\nobj.foo = 'bar';\nval\n",
- "SharedArrayBuffer": "\n// Assuming an environment supports SharedArrayBuffers...\nbuf = new SharedArrayBuffer( 5 )\n",
- "shift": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\nout = shift( arr )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\nout = shift( arr )\n\n// Array-like object:\narr = { 'length': 2, '0': 1.0, '1': 2.0 };\nout = shift( arr )\n",
- "shuffle": "data = [ 1, 2, 3 ];\nout = shuffle( data )\nout = shuffle( data, { 'copy': 'none' });\nbool = ( data === out )\n",
- "sizeOf": "s = sizeOf( 'int8' )\ns = sizeOf( 'uint32' )\n",
- "some": "arr = [ 0, 0, 1, 2, 3 ];\nbool = some( arr, 3 )\n",
- "someBy": "function negative( v ) { return ( v < 0 ); };\narr = [ 1, 2, -3, 4, -1 ];\nbool = someBy( arr, 2, negative )\n",
- "someByAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000 ];\nsomeByAsync( arr, 2, opts, predicate, done )\n",
- "someByRight": "function negative( v ) { return ( v < 0 ); };\narr = [ -1, 1, -2, 3, 4 ];\nbool = someByRight( arr, 2, negative )\n",
- "someByRightAsync": "\n// Basic usage:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\narr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, predicate, done )\n\n// Limit number of concurrent invocations:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'limit': 2 };\narr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n\n// Process sequentially:\nfunction predicate( value, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, false );\n }\n};\nfunction done( error, bool ) {\n if ( error ) {\n throw error;\n }\n console.log( bool );\n};\nopts = { 'series': true };\narr = [ 1000, 2500, 3000 ];\nsomeByRightAsync( arr, 2, opts, predicate, done )\n",
- "SOTU": "out = SOTU()\n\n// Retrieve addresses by one or more Presidents...\nopts = { 'name': 'Barack Obama' };\nout = SOTU( opts )\n\n// Retrieve addresses by one or more political parties...\nopts = { 'party': [ 'Democratic', 'Federalist' ] };\nout = SOTU( opts )\n\n// Retrieve addresses from one or more years...\nopts = { 'year': [ 2008, 2009, 2011 ] };\nout = SOTU( opts )\n\n// Retrieve addresses from a range of consecutive years...\nopts = { 'range': [ 2008, 2016 ] }\nout = SOTU( opts )\n",
- "SPACHE_REVISED": "list = SPACHE_REVISED()\n",
- "SPAM_ASSASSIN": "data = SPAM_ASSASSIN()\n",
- "SparklineBase": "sparkline = new SparklineBase()\n\n// Provide sparkline data at instantiation:\ndata = [ 1, 2, 3 ];\nsparkline = new SparklineBase( data )\n",
- "sparsearray2iterator": "it = sparsearray2iterator( [ 1, , 3, 4 ] );\nv = it.next().value\nv = it.next().value\n",
- "sparsearray2iteratorRight": "it = sparsearray2iteratorRight( [ 1, 2, , 4 ] );\nv = it.next().value\nv = it.next().value\n",
- "splitStream": "s = splitStream();\ns.write( 'a\\nb\\nc' );\ns.end();\n",
- "SQRT_EPS": "SQRT_EPS\n",
- "SQRT_HALF": "SQRT_HALF\n",
- "SQRT_HALF_PI": "SQRT_HALF_PI\n",
- "SQRT_PHI": "SQRT_PHI\n",
- "SQRT_PI": "SQRT_PI\n",
- "SQRT_THREE": "SQRT_THREE\n",
- "SQRT_TWO": "SQRT_TWO\n",
- "SQRT_TWO_PI": "SQRT_TWO_PI\n",
- "Stack": "s = Stack();\ns.push( 'foo' ).push( 'bar' );\ns.length\ns.pop()\ns.length\ns.pop()\ns.length\n",
- "startcase": "out = startcase( 'beep boop' )\n",
- "startsWith": "bool = startsWith( 'Beep', 'Be' )\nbool = startsWith( 'Beep', 'ep' )\nbool = startsWith( 'Beep', 'ee', 1 )\nbool = startsWith( 'Beep', 'ee', -3 )\nbool = startsWith( 'Beep', '' )\n",
- "STOPWORDS_EN": "list = STOPWORDS_EN()\n",
- "stridedarray2iterator": "it = stridedarray2iterator( 2, [ 1, 2, 3, 4 ], -2, 3 );\nv = it.next().value\nv = it.next().value\n",
- "stridedArrayStream": "function fcn( chunk ) { console.log( chunk.toString() ); };\ns = stridedArrayStream( 3, [ 1, 2, 3 ], 1, 0 );\no = inspectSinkStream( fcn );\ns.pipe( o );\n",
- "string2buffer": "b = string2buffer( 'beep boop' )\nb = string2buffer( '7468697320697320612074c3a97374', 'hex' );\nb.toString()\n",
- "sub2ind": "d = [ 3, 3, 3 ];\nidx = sub2ind( d, 1, 2, 2 )\n",
- "SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK": "data = SUTHAHARAN_MULTI_HOP_SENSOR_NETWORK()\n",
- "SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK": "data = SUTHAHARAN_SINGLE_HOP_SENSOR_NETWORK()\n",
- "Symbol": "s = ( Symbol ) ? Symbol( 'beep' ) : null\n",
- "tabulate": "collection = [ 'beep', 'boop', 'foo', 'beep' ];\nout = tabulate( collection )\n",
- "tabulateBy": "function indicator( value ) { return value[ 0 ]; };\ncollection = [ 'beep', 'boop', 'foo', 'beep' ];\nout = tabulateBy( collection, indicator )\n",
- "tabulateByAsync": "\n// Basic usage:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even': 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\narr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, indicator, done )\n\n// Limit number of concurrent invocations:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'limit': 2 };\narr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n\n// Process sequentially:\nfunction indicator( value, index, next ) {\n setTimeout( onTimeout, value );\n function onTimeout() {\n console.log( value );\n next( null, ( index%2 === 0 ) ? 'even' : 'odd' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nopts = { 'series': true };\narr = [ 3000, 2500, 1000, 750 ];\ntabulateByAsync( arr, opts, indicator, done )\n",
- "tic": "t = tic()\n",
- "timeit": "code = 'var x = Math.pow( Math.random(), 3 );';\ncode += 'if ( x !== x ) {';\ncode += 'throw new Error( \\'Something went wrong.\\' );';\ncode += '}';\nfunction done( error, results ) {\n if ( error ) {\n throw error;\n }\n console.dir( results );\n};\ntimeit( code, done )\n",
- "tmpdir": "dir = tmpdir()\n",
- "toc": "start = tic();\ndelta = toc( start )\n",
- "tokenize": "out = tokenize( 'Hello Mrs. Maple, could you call me back?' )\nout = tokenize( 'Hello World!', true )\n",
- "transformStream": "s = transformStream();\ns.write( 'a' );\ns.write( 'b' );\ns.write( 'c' );\ns.end();\n",
- "trim": "out = trim( ' \\t\\t\\n Beep \\r\\n\\t ' )\n",
- "trycatch": "function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nz = trycatch( x, -1.0 )\n",
- "trycatchAsync": "function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n // process error...\n }\n console.log( result );\n};\ntrycatchAsync( x, 'boop', done )\n",
- "tryFunction": "function fcn() { throw new Error( 'beep boop' ); };\nf = tryFunction( fcn );\nout = f();\nout.message\n",
- "tryRequire": "out = tryRequire( '_unknown_module_id_' )\n",
- "trythen": "function x() {\n if ( base.random.randu() < 0.5 ) {\n throw new Error( 'beep' );\n }\n return 1.0;\n};\nfunction y() {\n return -1.0;\n};\nz = trythen( x, y )\n",
- "trythenAsync": "function x( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( new Error( 'beep' ) );\n }\n};\nfunction y( clbk ) {\n setTimeout( onTimeout, 0 );\n function onTimeout() {\n clbk( null, 'boop' );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\ntrythenAsync( x, y, done )\n",
- "ttest": "\n// One-sample t-test:\nrnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 5776 });\nx = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nout = ttest( x )\n\n// Paired t-test:\nrnorm = base.random.normal.factory( 1.0, 2.0, { 'seed': 786 });\nx = new Array( 100 );\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n y[ i ] = rnorm();\n}\nout = ttest( x, y )\n\n// Print formatted output:\ntable = out.print()\n\n// Choose custom significance level:\narr = [ 2, 4, 3, 1, 0 ];\nout = ttest( arr, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\narr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ttest( arr, { 'alternative': 'less' });\ntable = out.print()\nout = ttest( arr, { 'alternative': 'greater' });\ntable = out.print()\n",
- "ttest2": "\n// Student's sleep data:\nx = [ 0.7, -1.6, -0.2, -1.2, -0.1, 3.4, 3.7, 0.8, 0.0, 2.0 ];\ny = [ 1.9, 0.8, 1.1, 0.1, -0.1, 4.4, 5.5, 1.6, 4.6, 3.4 ];\nout = ttest2( x, y )\n\n// Print table output:\ntable = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ttest2( x, y, { 'alpha': 0.1 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ttest2( x, y, { 'alternative': 'less' });\ntable = out.print()\nout = ttest2( x, y, { 'alternative': 'greater' });\ntable = out.print()\n\n// Run tests with equal variances assumption:\nx = [ 2, 3, 1, 4 ];\ny = [ 1, 2, 3, 1, 2, 5, 3, 4 ];\nout = ttest2( x, y, { 'variance': 'equal' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nrnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 3.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 1.0, 3.0 );\n}\nout = ttest2( x, y, { 'difference': 1.0, 'variance': 'equal' })\n",
- "TWO_PI": "TWO_PI\n",
- "typedarray": "arr = typedarray()\narr = typedarray( 'float32' )\n",
- "typedarray2json": "arr = new Float64Array( 2 );\narr[ 0 ] = 5.0;\narr[ 1 ] = 3.0;\njson = typedarray2json( arr )\n",
- "typedarrayComplexCtors": "ctor = typedarrayComplexCtors( 'complex64' )\nctor = typedarrayComplexCtors( 'float32' )\n",
- "typedarrayComplexDataTypes": "out = typedarrayComplexDataTypes()\n",
- "typedarrayCtors": "ctor = typedarrayCtors( 'float64' )\nctor = typedarrayCtors( 'float' )\n",
- "typedarrayDataTypes": "out = typedarrayDataTypes()\n",
- "typedarraypool": "arr = typedarraypool()\narr = typedarraypool( 'float32' )\n",
- "typemax": "m = typemax( 'int8' )\nm = typemax( 'uint32' )\n",
- "typemin": "m = typemin( 'int8' )\nm = typemin( 'uint32' )\n",
- "typeOf": "\n// Built-ins:\nt = typeOf( 'a' )\nt = typeOf( 5 )\nt = typeOf( NaN )\nt = typeOf( true )\nt = typeOf( false )\nt = typeOf( null )\nt = typeOf( undefined )\nt = typeOf( [] )\nt = typeOf( {} )\nt = typeOf( function noop() {} )\nt = typeOf( Symbol( 'beep' ) )\nt = typeOf( /.+/ )\nt = typeOf( new String( 'beep' ) )\nt = typeOf( new Number( 5 ) )\nt = typeOf( new Boolean( false ) )\nt = typeOf( new Array() )\nt = typeOf( new Object() )\nt = typeOf( new Int8Array( 10 ) )\nt = typeOf( new Uint8Array( 10 ) )\nt = typeOf( new Uint8ClampedArray( 10 ) )\nt = typeOf( new Int16Array( 10 ) )\nt = typeOf( new Uint16Array( 10 ) )\nt = typeOf( new Int32Array( 10 ) )\nt = typeOf( new Uint32Array( 10 ) )\nt = typeOf( new Float32Array( 10 ) )\nt = typeOf( new Float64Array( 10 ) )\nt = typeOf( new ArrayBuffer( 10 ) )\nt = typeOf( new Date() )\nt = typeOf( new RegExp( '.+' ) )\nt = typeOf( new Map() )\nt = typeOf( new Set() )\nt = typeOf( new WeakMap() )\nt = typeOf( new WeakSet() )\nt = typeOf( new Error( 'beep' ) )\nt = typeOf( new TypeError( 'beep' ) )\nt = typeOf( new SyntaxError( 'beep' ) )\nt = typeOf( new ReferenceError( 'beep' ) )\nt = typeOf( new URIError( 'beep' ) )\nt = typeOf( new RangeError( 'beep' ) )\nt = typeOf( new EvalError( 'beep' ) )\nt = typeOf( Math )\nt = typeOf( JSON )\n\n// Arguments object:\nfunction beep() { return arguments; };\nt = typeOf( beep() )\n\n// Node.js Buffer object:\nt = typeOf( new Buffer( 10 ) )\n\n// Custom constructor:\nfunction Person() { return this };\nt = typeOf( new Person() )\n\n// Anonymous constructor:\nFoo = function () { return this; };\nt = typeOf( new Foo() )\n",
- "UINT8_MAX": "UINT8_MAX\n",
- "UINT8_NUM_BYTES": "UINT8_NUM_BYTES\n",
- "Uint8Array": "arr = new Uint8Array()\n",
- "Uint8ClampedArray": "arr = new Uint8ClampedArray()\n",
- "UINT16_MAX": "UINT16_MAX\n",
- "UINT16_NUM_BYTES": "UINT16_NUM_BYTES\n",
- "Uint16Array": "arr = new Uint16Array()\n",
- "UINT32_MAX": "UINT32_MAX\n",
- "UINT32_NUM_BYTES": "UINT32_NUM_BYTES\n",
- "Uint32Array": "arr = new Uint32Array()\n",
- "umask": "mask = umask()\nmask = umask( { 'symbolic': true } )\n",
- "uncapitalize": "out = uncapitalize( 'Beep' )\nout = uncapitalize( 'bOOp' )\n",
- "uncapitalizeKeys": "obj = { 'AA': 1, 'BB': 2 };\nout = uncapitalizeKeys( obj )\n",
- "uncurry": "function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nfcn = uncurry( addX );\nsum = fcn( 2, 3 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( x ) {\n return function add( y ) {\n return x + y;\n };\n};\nfcn = uncurry( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addX( x ) {\n this.x = x;\n return addY;\n};\nfunction addY( y ) {\n return this.x + y;\n};\nfcn = uncurry( addX, {} );\nsum = fcn( 2, 3 )\n",
- "uncurryRight": "function addX( x ) {\n return function addY( y ) {\n return x + y;\n };\n};\nfcn = uncurryRight( addX );\nsum = fcn( 3, 2 )\n\n// To enforce a fixed number of parameters, provide an `arity` argument:\nfunction add( y ) {\n return function add( x ) {\n return x + y;\n };\n};\nfcn = uncurryRight( add, 2 );\nsum = fcn( 9 )\n\n// To specify an execution context, provide a `thisArg` argument:\nfunction addY( y ) {\n this.y = y;\n return addX;\n};\nfunction addX( x ) {\n return x + this.y;\n};\nfcn = uncurryRight( addY, {} );\nsum = fcn( 3, 2 )\n",
- "UNICODE_MAX": "UNICODE_MAX\n",
- "UNICODE_MAX_BMP": "UNICODE_MAX_BMP\n",
- "UnicodeColumnChartSparkline": "data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nchart = new UnicodeColumnChartSparkline( data );\nchart.render()\n",
- "UnicodeLineChartSparkline": "data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nchart = new UnicodeLineChartSparkline( data );\nchart.render()\n",
- "UnicodeSparkline": "data = [ 1.0, 5.0, 3.0, 2.0, 4.0, 4.0, 3.0 ];\nchart = new UnicodeSparkline( data );\nchart.render()\nchart.type = 'line';\nchart.render()\n",
- "UnicodeTristateChartSparkline": "data = [ -1, 1, 0, 0, 1, -1, -1, 1 ];\nchart = new UnicodeTristateChartSparkline( data );\nchart.render()\n",
- "UnicodeUpDownChartSparkline": "data = [ -1, 1, 1, 1, 1, -1, -1, 1 ];\nchart = new UnicodeUpDownChartSparkline( data );\nchart.render()\n",
- "UnicodeWinLossChartSparkline": "data = [ -2, 1, 2, 2, 1, -1, -1, 1 ];\nchart = new UnicodeWinLossChartSparkline( data );\nchart.render()\n",
- "unlink": "function done( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nunlink( './beep/boop.txt', done );\n",
- "unshift": "\n// Arrays:\narr = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\narr = unshift( arr, 6.0, 7.0 )\n\n// Typed arrays:\narr = new Float64Array( [ 1.0, 2.0 ] );\narr = unshift( arr, 3.0, 4.0 )\n\n// Array-like object:\narr = { 'length': 1, '0': 1.0 };\narr = unshift( arr, 2.0, 3.0 )\n",
- "until": "function predicate( i ) { return ( i >= 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nuntil( predicate, beep )\n",
- "untilAsync": "function predicate( i, clbk ) { clbk( null, i >= 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nuntilAsync( predicate, fcn, done )\n",
- "untilEach": "function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4, NaN, 5 ];\nuntilEach( arr, predicate, logger )\n",
- "untilEachRight": "function predicate( v ) { return v !== v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, NaN, 2, 3, 4, 5 ];\nuntilEachRight( arr, predicate, logger )\n",
- "unzip": "\n// Basic usage:\narr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nout = unzip( arr )\n\n// Provide indices:\narr = [ [ 1, 'a', 3 ], [ 2, 'b', 4 ] ];\nout = unzip( arr, [ 0, 2 ] )\n",
- "uppercase": "out = uppercase( 'bEEp' )\n",
- "uppercaseKeys": "obj = { 'a': 1, 'b': 2 };\nout = uppercaseKeys( obj )\n",
- "US_STATES_ABBR": "list = US_STATES_ABBR()\n",
- "US_STATES_CAPITALS": "list = US_STATES_CAPITALS()\n",
- "US_STATES_CAPITALS_NAMES": "out = US_STATES_CAPITALS_NAMES()\n",
- "US_STATES_NAMES": "list = US_STATES_NAMES()\n",
- "US_STATES_NAMES_CAPITALS": "out = US_STATES_NAMES_CAPITALS()\n",
- "utf16ToUTF8Array": "str = '☃';\nout = utf16ToUTF8Array( str )\n",
- "vartest": "x = [ 610, 610, 550, 590, 565, 570 ];\ny = [ 560, 550, 580, 550, 560, 590, 550, 590 ];\nout = vartest( x, y )\n\n// Print table output:\ntable = out.print()\n",
- "waterfall": "function foo( next ) { next( null, 'beep' ); };\nfunction bar( str, next ) { console.log( str ); next(); };\nfunction done( error ) { if ( error ) { throw error; } };\nfcns = [ foo, bar ];\nwaterfall( fcns, done );\n",
- "whileAsync": "function predicate( i, clbk ) { clbk( null, i < 5 ); };\nfunction fcn( i, next ) {\n setTimeout( onTimeout, i );\n function onTimeout() {\n next( null, 'boop'+i );\n }\n};\nfunction done( error, result ) {\n if ( error ) {\n throw error;\n }\n console.log( result );\n};\nwhileAsync( predicate, fcn, done )\n",
- "whileEach": "function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, 2, 3, 4, NaN, 5 ];\nwhileEach( arr, predicate, logger )\n",
- "whileEachRight": "function predicate( v ) { return v === v; };\nfunction logger( v, i ) { console.log( '%s: %d', i, v ); };\narr = [ 1, NaN, 2, 3, 4, 5 ];\nwhileEachRight( arr, predicate, logger )\n",
- "whilst": "function predicate( i ) { return ( i < 5 ); };\nfunction beep( i ) { console.log( 'boop: %d', i ); };\nwhilst( predicate, beep )\n",
- "writableProperties": "function Foo() { this.beep = 'boop'; return this; };\nFoo.prototype.foo = 'bar';\nobj = new Foo();\nprops = writableProperties( obj )\n",
- "writablePropertiesIn": "props = writablePropertiesIn( [] )\n",
- "writablePropertyNames": "obj = { 'a': 'b' };\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nkeys = writablePropertyNames( obj )\n",
- "writablePropertyNamesIn": "obj = { 'a': 'b' };\ndesc = {};\ndesc.configurable = true;\ndesc.enumerable = true;\ndesc.writable = false;\ndesc.value = 'boop';\ndefineProperty( obj, 'beep', desc );\nkeys = writablePropertyNamesIn( obj )\n",
- "writablePropertySymbols": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = writablePropertySymbols( obj )\n",
- "writablePropertySymbolsIn": "obj = {};\ndesc = {};\ndesc.configurable = false;\ndesc.enumerable = false;\ndesc.writable = true;\ndesc.value = 'boop';\nsym = ( Symbol ) ? Symbol( 'beep' ) : 'beep';\ndefineProperty( obj, sym, desc );\nsymbols = writablePropertySymbolsIn( obj )\n",
- "writeFile": "function onWrite( error ) {\n if ( error ) {\n console.error( error.message );\n }\n};\nwriteFile( './beep/boop.txt', 'beep boop', onWrite );\n",
- "zip": "\n// Basic usage:\nout = zip( [ 1, 2 ], [ 'a', 'b' ] )\n\n// Turn off truncation:\nopts = { 'trunc': false };\nout = zip( [ 1, 2, 3 ], [ 'a', 'b' ], opts )\n",
- "ztest": "\n// One-sample z-test:\nrnorm = base.random.normal.factory( 0.0, 2.0, { 'seed': 212 });\nx = new Array( 100 );\nfor ( var i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm();\n}\nout = ztest( x, 2.0 )\n\n// Choose custom significance level and print output:\narr = [ 2, 4, 3, 1, 0 ];\nout = ztest( arr, 2.0, { 'alpha': 0.01 });\ntable = out.print()\n\n// Test for a mean equal to five:\narr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'mu': 5 })\n\n// Perform one-sided tests:\narr = [ 4, 4, 6, 6, 5 ];\nout = ztest( arr, 1.0, { 'alternative': 'less' })\nout = ztest( arr, 1.0, { 'alternative': 'greater' })\n",
- "ztest2": "\n// Drawn from Normal(0,2):\nx = [ -0.21, 0.14, 1.65, 2.11, -1.86, -0.29, 1.48, 0.81, 0.86, 1.04 ];\n\n// Drawn from Normal(1,2):\ny = [ -1.53, -2.93, 2.34, -1.15, 2.7, -0.12, 4.22, 1.66, 3.43, 4.66 ];\nout = ztest2( x, y, 2.0, 2.0 )\n\n// Print table output:\ntable = out.print()\n\n// Choose a different significance level than `0.05`:\nout = ztest2( x, y, 2.0, 2.0, { 'alpha': 0.4 });\ntable = out.print()\n\n// Perform one-sided tests:\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'less' });\ntable = out.print()\nout = ztest2( x, y, 2.0, 2.0, { 'alternative': 'greater' });\ntable = out.print()\n\n// Test for a difference in means besides zero:\nrnorm = base.random.normal.factory({ 'seed': 372 });\nx = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n x[ i ] = rnorm( 2.0, 1.0 );\n}\ny = new Array( 100 );\nfor ( i = 0; i < x.length; i++ ) {\n y[ i ] = rnorm( 0.0, 2.0 );\n}\nout = ztest2( x, y, 1.0, 2.0, { 'difference': 2.0 })\n"
-};
-
-module.exports = db;
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/lib/index.js b/lib/node_modules/@stdlib/repl/code-blocks/lib/index.js
index 3e161988754b..a1caf6280c02 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/lib/index.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/lib/index.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -19,22 +19,22 @@
'use strict';
/**
-* REPL examples.
+* Return an example associated with a provided alias.
*
* @module @stdlib/repl/code-blocks
*
* @example
-* var examples = require( '@stdlib/repl/code-blocks' );
+* var example = require( '@stdlib/repl/code-blocks' );
*
-* var o = examples();
-* // returns {...}
+* var out = example( 'base.sin' );
+* // returns
*/
// MODULES //
-var examples = require( './main.js' );
+var example = require( './main.js' );
// EXPORTS //
-module.exports = examples;
+module.exports = example;
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/lib/main.js b/lib/node_modules/@stdlib/repl/code-blocks/lib/main.js
index afa9f149b4ed..aeee66fe89f2 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/lib/main.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/lib/main.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -20,26 +20,35 @@
// MODULES //
-var copy = require( '@stdlib/utils/copy' );
-var EXAMPLES = require( './db.js' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var ALIAS_TO_EXAMPLE = require( './../data/data.json' );
// MAIN //
/**
-* Returns REPL examples.
+* Returns an example associated with a specified alias.
*
-* @returns {Object} examples
+* @param {string} alias - alias
+* @throws {TypeError} must provide a string
+* @returns {(string|null)} example
*
* @example
-* var o = examples();
-* // returns {...}
+* var out = example( 'base.sin' );
+* // returns
*/
-function examples() {
- return copy( EXAMPLES );
+function example( alias ) {
+ if ( !isString( alias ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + alias + '`.' );
+ }
+ if ( hasOwnProp( ALIAS_TO_EXAMPLE, alias ) ) {
+ return ALIAS_TO_EXAMPLE[ alias ];
+ }
+ return null;
}
// EXPORTS //
-module.exports = examples;
+module.exports = example;
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/package.json b/lib/node_modules/@stdlib/repl/code-blocks/package.json
index f3ba7ee5c080..db0ab700c155 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/package.json
+++ b/lib/node_modules/@stdlib/repl/code-blocks/package.json
@@ -1,7 +1,7 @@
{
"name": "@stdlib/repl/code-blocks",
"version": "0.0.0",
- "description": "REPL examples.",
+ "description": "Return an example associated with a provided alias.",
"license": "Apache-2.0",
"author": {
"name": "The Stdlib Authors",
@@ -13,14 +13,20 @@
"url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
}
],
+ "bin": {
+ "stdlib-alias-help": "./bin/cli"
+ },
"main": "./lib",
"directories": {
"benchmark": "./benchmark",
+ "bin": "./bin",
+ "data": "./data",
+ "doc": "./docs",
"example": "./examples",
"lib": "./lib",
- "scripts": "./scripts",
"test": "./test"
},
+ "types": "./docs/types",
"scripts": {},
"homepage": "https://github.com/stdlib-js/stdlib",
"repository": {
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/scripts/build.js b/lib/node_modules/@stdlib/repl/code-blocks/scripts/build.js
index 815d3483e1bd..6bdf12102c56 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/scripts/build.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/scripts/build.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -25,28 +25,17 @@ var logger = require( 'debug' );
var objectKeys = require( '@stdlib/utils/keys' );
var replace = require( '@stdlib/string/replace' );
var writeFile = require( '@stdlib/fs/write-file' ).sync;
-var licenseHeader = require( '@stdlib/_tools/licenses/header' );
-var docs = require( '@stdlib/repl/help' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var help = require( '@stdlib/repl/help' );
// VARIABLES //
-var debug = logger( 'repl:examples:build' );
+var debug = logger( 'repl:code-blocks:build' );
-// Examples output file path:
-var EXAMPLES_OUTPUT = resolvePath( __dirname, '..', 'lib', 'db.js' );
-
-// License header options:
-var HEADER_OPTIONS = {
- 'copyright': 'The Stdlib Authors',
- 'year': ( new Date() ).getFullYear()
-};
-
-// Output file preamble:
-var PREAMBLE = '/* eslint-disable quotes, max-lines */\n\n'+licenseHeader( 'Apache-2.0', 'js', HEADER_OPTIONS )+'\n/*\n* This file is generated by scripts/build.js.\n*/\n\'use strict\';\n\nvar db = ';
-
-// Output file append:
-var APPEND = 'module.exports = db;\n';
+// Output file paths:
+var OUTPUT_JSON = resolvePath( __dirname, '..', 'data', 'data.json' );
+var OUTPUT_CSV = resolvePath( __dirname, '..', 'data', 'data.csv' );
// Identifier for inserting 'See Also' links:
var SEE_ALSO = '\n See Also\n --------\n';
@@ -78,43 +67,46 @@ var RE_IDENTATION = /^(\s{4})/;
// Regular expression for indentation (global):
var RE_IDENTATION_GLOBAL = /^(\s{4})/g;
-// Regular expression for variable declaration:
-var RE_VAR_DECLARATION = /^(var\s+)/;
-
// FUNCTIONS //
/**
-* Generates a hash for REPL examples.
+* Main execution sequence.
*
* @private
-* @param {Object} docs - hash containing REPL help text
*/
-function createExamples( docs ) {
- var aliases;
+function main() {
+ var ALIASES;
var alias;
var fopts;
var lines;
var line;
+ var json;
+ var keys;
+ var csv;
var acc;
var txt;
- var out;
var flg;
+ var tmp;
var i;
var j;
+ debug( 'Generating REPL examples.' );
fopts = {
'encoding': 'utf8'
};
- out = {};
+ json = {};
- aliases = objectKeys( docs );
- for ( i = 0; i < aliases.length; i++ ) {
- alias = aliases[ i ];
+ ALIASES = aliases();
+ for ( i = 0; i < ALIASES.length; i++ ) {
+ alias = ALIASES[ i ];
debug( 'Loading REPL text: %s', alias );
- txt = docs[ alias ];
-
+ txt = help( alias );
+ if ( txt === null ) {
+ debug( 'Unable to resolve alias help text: %s', alias );
+ continue;
+ }
debug( 'Extracting examples section.' );
lines = txt.split( '\n' );
flg = false;
@@ -144,7 +136,6 @@ function createExamples( docs ) {
line = replace( line, RE_PROMPT, '' );
line = replace( line, RE_CONTINUATION, '' );
line = replace( line, RE_IDENTATION_GLOBAL, ' ' );
- line = replace( line, RE_VAR_DECLARATION, '' ); // NOTE: the REPL silences output when declaring a variable. So we remove any variable declarations here.
acc += line + '\n';
} else if ( RE_COMMENT.test( line ) ) {
line = replace( line, RE_IDENTATION, '' );
@@ -159,22 +150,21 @@ function createExamples( docs ) {
if ( acc === '' ) {
debug( 'Unable to extract an examples section.' );
} else {
- out[ alias ] = acc;
+ json[ alias ] = acc;
}
}
- debug( 'Writing REPL example hash to file.' );
- out = PREAMBLE+JSON.stringify( out, null, '\t' )+';\n\n'+APPEND;
- writeFile( EXAMPLES_OUTPUT, out, fopts );
-}
-
-/**
-* Main execution sequence.
-*
-* @private
-*/
-function main() {
- debug( 'Generating REPL examples.' );
- createExamples( docs() );
+ debug( 'Writing to JSON file.' );
+ writeFile( OUTPUT_JSON, JSON.stringify( json ), fopts );
+
+ debug( 'Writing to CSV file.' );
+ keys = objectKeys( json );
+ csv = '';
+ for ( i = 0; i < keys.length; i++ ) {
+ tmp = replace( json[ keys[i] ], /\r?\n/g, '\\n' );
+ tmp = replace( tmp, '"', '\\"' );
+ csv += keys[ i ] + ',"' + tmp + '"\n'; // Note: ensures trailing newline
+ }
+ writeFile( OUTPUT_CSV, csv, fopts );
}
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/test/test.cli.js b/lib/node_modules/@stdlib/repl/code-blocks/test/test.cli.js
new file mode 100644
index 000000000000..0e4b59e6bdc5
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/code-blocks/test/test.cli.js
@@ -0,0 +1,184 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var exec = require( 'child_process' ).exec;
+var tape = require( 'tape' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var IS_WINDOWS = require( '@stdlib/assert/is-windows' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+
+
+// VARIABLES //
+
+var fpath = resolve( __dirname, '..', 'bin', 'cli' );
+var opts = {
+ 'skip': IS_BROWSER || IS_WINDOWS
+};
+
+
+// FIXTURES //
+
+var PKG_VERSION = require( './../package.json' ).version;
+
+
+// TESTS //
+
+tape( 'command-line interface', function test( t ) {
+ t.ok( true, __filename );
+ t.end();
+});
+
+tape( 'when invoked with a `--help` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '--help'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-h` flag, the command-line interface prints the help text to `stderr`', opts, function test( t ) {
+ var expected;
+ var cmd;
+
+ expected = readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ });
+ cmd = [
+ process.execPath,
+ fpath,
+ '-h'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), expected+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `--version` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '--version'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'when invoked with a `-V` flag, the command-line interface prints the version to `stderr`', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ '-V'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ t.strictEqual( stdout.toString(), '', 'does not print to `stdout`' );
+ t.strictEqual( stderr.toString(), PKG_VERSION+'\n', 'expected value' );
+ }
+ t.end();
+ }
+});
+
+tape( 'the command-line interface prints an example as text', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'base.sin'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.fail( error.message );
+ } else {
+ stdout = stdout.toString().split( '\n' );
+
+ // Greater than 1 in order to include the trailing newline:
+ t.strictEqual( stdout.length > 1, true, 'prints text' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ }
+ t.end();
+ }
+});
+
+tape( 'if unable to resolve an example, the command-line interface sets a non-zero exit code', opts, function test( t ) {
+ var cmd = [
+ process.execPath,
+ fpath,
+ 'fjaldfjadljfeoejreandfljasdfjadsfjs'
+ ];
+
+ exec( cmd.join( ' ' ), done );
+
+ function done( error, stdout, stderr ) {
+ if ( error ) {
+ t.pass( error.message );
+ t.strictEqual( error.code, 1, 'expected exit code' );
+ }
+ t.strictEqual( stdout.toString(), '', 'does not print to` stdout`' );
+ t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
+ t.end();
+ }
+});
diff --git a/lib/node_modules/@stdlib/repl/code-blocks/test/test.js b/lib/node_modules/@stdlib/repl/code-blocks/test/test.js
index 579a5e3d8561..d59d63b02d61 100644
--- a/lib/node_modules/@stdlib/repl/code-blocks/test/test.js
+++ b/lib/node_modules/@stdlib/repl/code-blocks/test/test.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -21,28 +21,75 @@
// MODULES //
var tape = require( 'tape' );
-var isPlainObject = require( '@stdlib/assert/is-plain-object' );
-var examples = require( './../lib' );
+var aliases = require( '@stdlib/namespace/aliases' );
+var DATA = require( './../data/data.json' );
+var example = require( './../lib' );
// TESTS //
tape( 'main export is a function', function test( t ) {
t.ok( true, __filename );
- t.strictEqual( typeof examples, 'function', 'main export is a function' );
+ t.strictEqual( typeof example, 'function', 'main export is a function' );
t.end();
});
-tape( 'the function returns REPL examples', function test( t ) {
- var o1;
- var o2;
+tape( 'the function throws an error if not provided a string', function test( t ) {
+ var values;
+ var i;
- o1 = examples();
- t.strictEqual( isPlainObject( o1 ), true, 'returns an object' );
+ 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() {
+ example( value );
+ };
+ }
+});
+
+tape( 'the function returns an example as text', function test( t ) {
+ var expected;
+ var actual;
+ var list;
+ var i;
+
+ list = aliases();
+ for ( i = 0; i < list.length; i++ ) {
+ expected = DATA[ list[i] ];
+ if ( expected === void 0 ) {
+ expected = null;
+ }
+ actual = example( list[i] );
+ t.strictEqual( actual, expected, 'returns expected value for '+list[i] );
+ }
+ t.end();
+});
- o2 = examples();
- t.strictEqual( isPlainObject( o2 ), true, 'returns an object' );
- t.notEqual( o1, o2, 'returns new reference' );
+tape( 'the function returns `null` if provided an unrecognized alias', function test( t ) {
+ var values;
+ var i;
+ values = [
+ 'adfkaljdfdsafs',
+ 'adklfadjflajdslfjalsdf',
+ 'adflkajdlkfjasdlkfjsadlkfjlasdjflsdjfla'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.strictEqual( example( values[ i ] ), null, 'returns expected value' );
+ }
t.end();
});
diff --git a/lib/node_modules/@stdlib/repl/ctor/benchmark/benchmark.js b/lib/node_modules/@stdlib/repl/ctor/benchmark/benchmark.js
new file mode 100644
index 000000000000..6ff484294a64
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/benchmark/benchmark.js
@@ -0,0 +1,93 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 inspectSinkStream = require( '@stdlib/streams/node/inspect-sink' );
+var randu = require( '@stdlib/random/streams/randu' );
+var noop = require( '@stdlib/utils/noop' );
+var pkg = require( './../package.json' ).name;
+var REPL = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg+'::new', function benchmark( b ) {
+ var sopts;
+ var opts;
+ var r;
+ var i;
+
+ opts = {
+ 'output': inspectSinkStream( noop )
+ };
+ sopts = {
+ 'iter': 1
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ opts.input = randu( sopts ); // Note: this is slow, but should not be rate-limiting
+ r = new REPL( opts );
+ if ( typeof r !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ r.close();
+ }
+ b.toc();
+ if ( !( r instanceof REPL ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::no_new', function benchmark( b ) {
+ var sopts;
+ var repl;
+ var opts;
+ var r;
+ var i;
+
+ repl = REPL;
+ opts = {
+ 'output': inspectSinkStream( noop )
+ };
+ sopts = {
+ 'iter': 1
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ opts.input = randu( sopts ); // Note: this is slow, but should not be rate-limiting
+ r = repl( opts );
+ if ( typeof r !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ r.close();
+ }
+ b.toc();
+ if ( !( r instanceof REPL ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/clear.txt b/lib/node_modules/@stdlib/repl/ctor/docs/clear.txt
new file mode 100644
index 000000000000..b3f3dfa8eba3
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/clear.txt
@@ -0,0 +1,8 @@
+
+clear()
+ Clears the REPL context.
+
+ Examples
+ --------
+ > clear()
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/example.txt b/lib/node_modules/@stdlib/repl/ctor/docs/example.txt
new file mode 100644
index 000000000000..2e4c2a37d4f8
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/example.txt
@@ -0,0 +1,28 @@
+
+example( alias )
+ Runs examples for a specified alias.
+
+ Parameters
+ ----------
+ alias: any
+ Alias (an object reference, literal, or a string).
+
+ Examples
+ --------
+ > example( {{alias:@stdlib/math/base/special/sin}} )
+ > example( '{{alias:@stdlib/math/base/special/sin}}' )
+
+
+example( alias. )
+ Runs examples for a specified property.
+
+ Parameters
+ ----------
+ alias.: any
+ Alias property (an object reference, literal, or a string).
+
+ Examples
+ --------
+ > example( {{alias:@stdlib/array/float64}}.from )
+ > example( '{{alias:@stdlib/array/float64}}.from' )
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/help.txt b/lib/node_modules/@stdlib/repl/ctor/docs/help.txt
new file mode 100644
index 000000000000..1f7ec409e4be
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/help.txt
@@ -0,0 +1,36 @@
+
+help()
+ Prints help text.
+
+ Examples
+ --------
+ > help()
+
+
+help( alias )
+ Prints help text for a specified alias.
+
+ Parameters
+ ----------
+ alias: any
+ Alias (an object reference, literal, or a string).
+
+ Examples
+ --------
+ > help( help )
+ > help( 'help' )
+
+
+help( alias. )
+ Prints help text for a specified property.
+
+ Parameters
+ ----------
+ alias.: any
+ Alias property (an object reference, literal, or a string).
+
+ Examples
+ --------
+ > help( {{alias:@stdlib/array/float64}}.from )
+ > help( '{{alias:@stdlib/array/float64}}.from' )
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/load.txt b/lib/node_modules/@stdlib/repl/ctor/docs/load.txt
new file mode 100644
index 000000000000..2b9fad8f016c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/load.txt
@@ -0,0 +1,14 @@
+
+load( fpath )
+ Loads and evaluates a JavaScript file, such as a REPL history file, line-by-
+ line.
+
+ Parameters
+ ----------
+ fpath: string
+ File path.
+
+ Examples
+ --------
+ > load( './path/to/file.js' )
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/quit.txt b/lib/node_modules/@stdlib/repl/ctor/docs/quit.txt
new file mode 100644
index 000000000000..34e1c08b5b03
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/quit.txt
@@ -0,0 +1,8 @@
+
+quit()
+ Exits the REPL.
+
+ Examples
+ --------
+ > quit()
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/record_start.txt b/lib/node_modules/@stdlib/repl/ctor/docs/record_start.txt
new file mode 100644
index 000000000000..bbb1d79bc48c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/record_start.txt
@@ -0,0 +1,23 @@
+
+recordStart( fpath )
+ Starts saving commands to a specified file path.
+
+ Parameters
+ ----------
+ fpath: string
+ File path.
+
+ Returns
+ -------
+ id: number
+ Record identifier.
+
+ Examples
+ --------
+ > var id = recordStart( './path/to/file.js' );
+ > 1 + 1
+ 2
+ > 'foo'
+ 'foo'
+ > recordStop( id );
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/record_stop.txt b/lib/node_modules/@stdlib/repl/ctor/docs/record_stop.txt
new file mode 100644
index 000000000000..f552e1eff5b9
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/record_stop.txt
@@ -0,0 +1,25 @@
+
+recordStop( id )
+ Stops saving commands to a file path associated with a specified record
+ identifier.
+
+ Parameters
+ ----------
+ id: number
+ Record identifier.
+
+ Returns
+ -------
+ bool: boolean
+ Boolean indicating whether the REPL successfully stopped saving
+ evaluated commands.
+
+ Examples
+ --------
+ > var id = recordStart( './path/to/file.js' );
+ > 1 + 1
+ 2
+ > 'foo'
+ 'foo'
+ > recordStop( id );
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/docs/save.txt b/lib/node_modules/@stdlib/repl/ctor/docs/save.txt
new file mode 100644
index 000000000000..28db238a0fe4
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/docs/save.txt
@@ -0,0 +1,13 @@
+
+save( fpath )
+ Saves previous commands to a specified file path.
+
+ Parameters
+ ----------
+ fpath: string
+ File path.
+
+ Examples
+ --------
+ > save( './path/to/file.js' )
+
diff --git a/lib/node_modules/@stdlib/repl/ctor/examples/index.js b/lib/node_modules/@stdlib/repl/ctor/examples/index.js
new file mode 100644
index 000000000000..992da19e6295
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/examples/index.js
@@ -0,0 +1,37 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 REPL = require( './../lib' );
+
+var repl;
+
+function onExit() {
+ console.log( 'REPL closed.' );
+}
+
+function onTimeout() {
+ repl.close();
+}
+
+// Create a new REPL:
+repl = new REPL();
+repl.on( 'exit', onExit );
+
+setTimeout( onTimeout, 5000 );
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/aliases.js b/lib/node_modules/@stdlib/repl/ctor/lib/aliases.js
new file mode 100644
index 000000000000..468b5b2528ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/aliases.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 aliases = require( '@stdlib/namespace/aliases' );
+
+
+// MAIN //
+
+var ALIASES = aliases(); // NOTE: we assume all aliases are unique (no duplicates!)
+
+
+// EXPORTS //
+
+module.exports = ALIASES;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/clear.js b/lib/node_modules/@stdlib/repl/ctor/lib/clear.js
new file mode 100644
index 000000000000..07fa8c7e677c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/clear.js
@@ -0,0 +1,81 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-underscore-dangle */
+
+'use strict';
+
+// MODULES //
+
+var logger = require( 'debug' );
+var createContext = require( './create_context.js' );
+var displayPrompt = require( './display_prompt.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:clear' );
+
+
+// MAIN //
+
+/**
+* Clears a REPL's local context.
+*
+* @private
+* @param {REPL} repl - REPL instance
+*/
+function clear( repl ) {
+ debug( 'Clearing the local REPL context...' );
+
+ // Clear the command queue:
+ repl._queue.clear();
+
+ // Clear any command which has been buffered but not yet executed:
+ repl._cmd.length = 0;
+
+ // Clear the command history:
+ repl._history.length = 0;
+
+ // When sandboxed, create a new execution context...
+ if ( repl._sandbox ) {
+ repl._context = createContext( repl );
+ repl.emit( 'reset', repl._context );
+ }
+ // Clear an output TTY stream of any previous commands and output:
+ if ( repl._isTTY ) {
+ /*
+ * Clear the entire screen and scrollback history using [ANSI escape sequences][1].
+ *
+ * - `\u001b`: ESC, the escape character
+ * - `[H`: move cursor to upper left corner
+ * - `[2J`: clear the entire screen
+ * - `[3J`: clear the entire screen and delete all lines in the scrollback buffer (note: possible portability issues)
+ *
+ * [1]: https://en.wikipedia.org/wiki/ANSI_escape_code
+ */
+ repl._ostream.write( '\u001b[2J\u001b[H\u001b[2J\u001b[3J' );
+ }
+ // Display the command prompt:
+ displayPrompt( repl, false );
+}
+
+
+// EXPORTS //
+
+module.exports = clear;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/contains.js b/lib/node_modules/@stdlib/repl/ctor/lib/contains.js
new file mode 100644
index 000000000000..c525a07d7d24
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/contains.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+// MAIN //
+
+/**
+* Returns a boolean indicating if a strided array-like object contains a provided value.
+*
+* @private
+* @param {NonNegativeInteger} N - number of elements to search
+* @param {ArrayLike} arr - array to search
+* @param {integer} stride - index stride
+* @param {NonNegativeInteger} offset - index offset
+* @param {*} value - search value
+* @returns {boolean} boolean indicating if an array-like object contains a provided value
+*
+* @example
+* var arr = [ 1, 2, 3 ];
+*
+* var bool = contains( arr.length, arr, 1, 0, 2 );
+* // returns true
+*
+* bool = contains( arr.length, arr, 1, 0, 4 );
+* // returns false
+*/
+function contains( N, arr, stride, offset, value ) {
+ var idx;
+ var i;
+
+ idx = offset;
+ for ( i = 0; i < N; i++ ) {
+ if ( arr[ idx ] === value ) {
+ return true;
+ }
+ idx += stride;
+ }
+ return false;
+}
+
+
+// EXPORTS //
+
+module.exports = contains;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/create_accessor.js b/lib/node_modules/@stdlib/repl/ctor/lib/create_accessor.js
new file mode 100644
index 000000000000..cf8b9323da6c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/create_accessor.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+
+
+// MAIN //
+
+/**
+* Returns an accessor for loading an underlying implementation upon first access.
+*
+* @private
+* @param {Array} out - cache for storing resolved module exports
+* @param {Function} require - module loader
+* @param {string} alias - alias
+* @returns {Function} get accessor
+*/
+function createAccessor( out, require, alias ) {
+ return get;
+
+ /**
+ * Returns an underlying implementation.
+ *
+ * @private
+ * @returns {*} package export
+ */
+ function get() {
+ var v = require( alias2pkg( alias ) ); // eslint-disable-line stdlib/no-dynamic-require
+ out.push( alias, v );
+ return v;
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = createAccessor;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/create_context.js b/lib/node_modules/@stdlib/repl/ctor/lib/create_context.js
new file mode 100644
index 000000000000..ac8ba04df3e6
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/create_context.js
@@ -0,0 +1,421 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-underscore-dangle */
+
+'use strict';
+
+// MODULES //
+
+var Module = require( 'module' );
+var vm = require( 'vm' );
+var Console = require( 'console' ).Console;
+var logger = require( 'debug' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var RE_EOL = require( '@stdlib/regexp/eol' );
+var getGlobal = require( '@stdlib/utils/global' );
+var objectKeys = require( '@stdlib/utils/keys' );
+var propertyDescriptor = require( '@stdlib/utils/property-descriptor' );
+var setReadOnly = require( '@stdlib/utils/define-read-only-property' );
+var setConfigurableReadOnly = require( '@stdlib/utils/define-configurable-read-only-property' );
+var alias2pkg = require( '@stdlib/namespace/alias2pkg' );
+var alias2related = require( '@stdlib/namespace/alias2related' );
+var alias2help = require( '@stdlib/repl/help' );
+var alias2example = require( '@stdlib/repl/code-blocks' );
+var indexOf = require( './index_of.js' );
+var createRequire = require( './create_require.js' );
+var HELP_TEXT = require( './help_text.js' );
+var GLOBALS = require( './globals.js' );
+var setAliases = require( './set_aliases.js' );
+var setAliasesGlobal = require( './set_aliases_global.js' );
+var setCommands = require( './set_commands.js' );
+var setCommandsGlobal = require( './set_commands_global.js' );
+var displayPrompt = require( './display_prompt.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:context' );
+
+// Cache references to module methods (WARNING: use of *private* methods exposed on the `Module` object; thus, breakage is possible!):
+var resolveLookupPaths = Module._resolveLookupPaths;
+
+// List of project aliases which are overridden/wrapped to provide behavior tailored to the REPL environment:
+var OVERRIDES = [
+ 'alias2pkg',
+ 'alias2related'
+];
+
+
+// MAIN //
+
+/**
+* Creates a REPL context.
+*
+* @private
+* @param {REPL} repl - REPL instance
+* @returns {Object} REPL context
+*/
+function createContext( repl ) {
+ var context;
+ var Global;
+ var keys;
+ var cmds;
+ var i;
+
+ debug( 'Creating REPL execution context...' );
+
+ Global = getGlobal();
+ if ( repl._sandbox ) {
+ // Create a sandboxed context:
+ context = vm.createContext();
+
+ // Assign globals from the current global context to the sandboxed context (note: shallow copy!)...
+ keys = objectKeys( GLOBALS );
+ for ( i = 0; i < keys.length; i++ ) {
+ setReadOnly( context, keys[ i ], GLOBALS[ keys[ i ] ] );
+ }
+ // Create a circular reference as in Node.js:
+ setReadOnly( context, 'global', context );
+
+ // Create a new `console` interface:
+ setReadOnly( context, 'console', new Console( repl._ostream ) );
+
+ // Create a new `module` object:
+ setReadOnly( context, 'module', new Module( '' ) );
+
+ // Create a new `require` function:
+ setReadOnly( context, 'require', createRequire( context.module ) );
+ } else {
+ context = Global;
+
+ // Create a new `module` object:
+ setConfigurableReadOnly( context, 'module', new Module( '' ) );
+
+ // Create a new `require` function:
+ setConfigurableReadOnly( context, 'require', createRequire( context.module ) );
+ }
+ context.module.paths = resolveLookupPaths( '', module, true ) || [];
+
+ // Add project APIs...
+ if ( repl._sandbox ) {
+ setAliases( repl._aliases, context, OVERRIDES );
+ } else {
+ setAliasesGlobal( repl._globalVars, repl._aliases, context, OVERRIDES );
+ }
+
+ // Define a list of REPL-specific commands (NOTE: keep in alphabetical order):
+ cmds = [
+ // [ , , ]
+ [ 'alias2pkg', onAlias2Pkg, false ],
+ [ 'alias2related', onAlias2Related, false ],
+ [ 'ans', onAns, true ],
+ [ 'clear', onClear, false ],
+ [ 'example', onExample, false ],
+ [ 'help', onHelp, false ],
+ [ 'isKeyword', isKeyword, false ],
+ [ 'load', onLoad, false ],
+ [ 'quit', onQuit, false ]
+ ];
+
+ // TODO: add `save` command
+
+ // TODO: add `saveStart` command
+
+ // TODO: add `saveStop` command
+
+ // TODO: add `citation` command
+
+ // TODO: add `license` command
+
+ // TODO: add `copyright` command
+
+ // TODO: add `contributors` command
+
+ // TODO: add `credits` command
+
+ // TODO: add `donate` command
+
+ // Add commands requiring privileged access to internal instance variables...
+ if ( repl._sandbox ) {
+ setCommands( context, cmds );
+ } else {
+ setCommandsGlobal( repl._globalVars, context, cmds );
+ }
+ return context;
+
+ /**
+ * Returns the package name corresponding to a provided alias.
+ *
+ * @private
+ * @param {*} alias - alias
+ * @returns {(string|void)} package name
+ */
+ function onAlias2Pkg( alias ) {
+ var aliases;
+ var out;
+ var N;
+ var i;
+
+ aliases = repl._aliases;
+ N = aliases.length;
+
+ if ( isString( alias ) ) {
+ out = alias2pkg( alias );
+ }
+ // If provided an `alias` which is not a string or we failed to resolve a package name based on the provided string value, we try to resolve a string alias (and subsequently a corresponding package name) by searching the list of cached references of global variables/properties...
+ if ( !out ) {
+ i = indexOf( N/2, aliases, 2, 1, alias );
+ if ( i >= 0 ) {
+ out = alias2pkg( aliases[ i-1 ] );
+ }
+ }
+ if ( out ) {
+ return out;
+ }
+ repl._ostream.write( 'Error: unrecognized alias. Alias: `'+alias+'`.\n' );
+ }
+
+ /**
+ * Returns aliases related to a provided alias.
+ *
+ * @private
+ * @param {*} alias - alias
+ * @returns {(StringArray|void)} related packages as a newline-delimited list
+ */
+ function onAlias2Related( alias ) {
+ var aliases;
+ var out;
+ var N;
+ var i;
+
+ aliases = repl._aliases;
+ N = aliases.length;
+
+ if ( isString( alias ) ) {
+ out = alias2related( alias );
+ }
+ // If provided an `alias` which is not a string or we failed to resolve related aliases based on the provided string value, we try to resolve a string alias (and subsequently related aliases) by searching the list of cached references of global variables/properties...
+ if ( !out ) {
+ i = indexOf( N/2, aliases, 2, 1, alias );
+ if ( i >= 0 ) {
+ out = alias2related( aliases[ i-1 ] );
+ }
+ }
+ if ( out === void 0 || out === null ) {
+ repl._ostream.write( 'Error: unrecognized alias. Alias: `'+alias+'`.\n' );
+ return;
+ }
+ if ( out.length ) {
+ return out;
+ }
+ }
+
+ /**
+ * Returns the result of the last successfully executed command.
+ *
+ * @private
+ * @returns {*} result
+ */
+ function onAns() {
+ return repl._ans;
+ }
+
+ /**
+ * Clears a REPL's local context.
+ *
+ * @private
+ */
+ function onClear() {
+ repl.clear();
+ }
+
+ /**
+ * Runs an example.
+ *
+ * @private
+ * @param {*} alias - variable alias or value
+ * @returns {void}
+ */
+ function onExample( alias ) {
+ var aliases;
+ var out;
+ var N;
+ var i;
+
+ aliases = repl._aliases;
+ N = aliases.length;
+
+ if ( isString( alias ) ) {
+ out = alias2example( alias );
+ }
+ // If provided an `alias` which is not a string or we failed to resolve an associated example based on the provided string value, we try to resolve a string alias (and subsequently a corresponding example) by searching the list of cached references of global variables/properties...
+ if ( !out ) {
+ i = indexOf( N/2, aliases, 2, 1, alias );
+ if ( i >= 0 ) {
+ out = alias2example( aliases[ i-1 ] );
+ }
+ }
+ // TODO: add support for running examples for REPL-specific namespace
+
+ if ( out ) {
+ out = out.split( RE_EOL );
+
+ // Reset the display prompt:
+ repl._rli.write( '\n' );
+ displayPrompt( repl, false );
+
+ // Forward each line to the REPL readline interface in order to mimic user input...
+ for ( i = 0; i < out.length; i++ ) {
+ if ( out[ i ] ) {
+ repl._rli.write( out[ i ]+'\n' );
+ displayPrompt( repl, false );
+ }
+ }
+ return;
+ }
+ repl._ostream.write( 'Error: no example available. Alias: `'+alias+'`.\n' );
+ }
+
+ /**
+ * Prints help text.
+ *
+ * @private
+ * @param {*} [alias] - variable alias or value
+ * @returns {void}
+ */
+ function onHelp( alias ) {
+ var aliases;
+ var out;
+ var N;
+ var i;
+ if ( arguments.length === 0 ) {
+ repl._ostream.write( HELP_TEXT );
+ return;
+ }
+ aliases = repl._aliases;
+ N = aliases.length;
+
+ if ( isString( alias ) ) {
+ out = alias2help( alias );
+ }
+ // If provided an `alias` which is not a string or we failed to resolve a help text based on the provided string value, we try to resolve a string alias (and subsequently a corresponding help text) by searching the list of cached references of global variables/properties...
+ if ( !out ) {
+ i = indexOf( N/2, aliases, 2, 1, alias );
+ if ( i >= 0 ) {
+ out = alias2help( aliases[ i-1 ] );
+ }
+ }
+ // TODO: add support for printing help text for REPL-specific namespace
+
+ if ( out ) {
+ repl._ostream.write( out+'\n' );
+ return;
+ }
+ repl._ostream.write( 'Error: no help information available. Alias: `'+alias+'`.\n' );
+ }
+
+ /**
+ * Returns a boolean indicating whether a string is a reserved keyword in the REPL environment.
+ *
+ * ## Notes
+ *
+ * - This function supports nested keyword paths (e.g., `base.sin`).
+ *
+ * @private
+ * @param {string} keyword - string to test
+ * @returns {(boolean|void)} boolean indicating whether a string is a reserved keyword
+ */
+ function isKeyword( keyword ) {
+ var desc;
+ var err;
+ var o;
+ var i;
+ var k;
+ if ( !isString( keyword ) ) {
+ err = new TypeError( 'invalid argument. Must provide a string. Value: `'+keyword+'`.' );
+ debug( 'Error: %s', err.message );
+ repl._ostream.write( 'Error: '+err.message+'\n' );
+ return;
+ }
+ // Our proxy for determining whether a value is a keyword is whether the value is read-only property on the `context` object, as any properties we have added to the `context` object are read-only (note, however, that, in a non-sandboxed environment, the `global` object may have read-only properties we have *not* introduced; meaning, some values which may be flagged as "keywords" were not introduced by us):
+ keyword = keyword.split( '.' );
+ o = context;
+ for ( i = 0; i < keyword.length-1; i++ ) {
+ k = keyword[ i ];
+ if ( !hasOwnProp( o, k ) ) {
+ return false;
+ }
+ o = o[ k ];
+ }
+ k = keyword[ i ];
+ desc = propertyDescriptor( o, k );
+ return (
+ desc !== null &&
+ (
+ // Data descriptor:
+ desc.writable === false ||
+
+ // Accessor descriptor:
+ (
+ typeof desc.get === 'function' &&
+ desc.set === void 0
+ )
+ )
+ );
+ }
+
+ /**
+ * Loads and evaluates a JavaScript file line-by-line.
+ *
+ * @private
+ * @param {string} fpath - file path
+ * @returns {void}
+ */
+ function onLoad( fpath ) {
+ var err;
+ if ( !isString( fpath ) ) {
+ err = new TypeError( 'invalid argument. Must provide a string. Value: `'+fpath+'`.' );
+ debug( 'Error: %s', err.message );
+ repl._ostream.write( 'Error: '+err.message+'\n' );
+ return;
+ }
+ // Reset the display prompt:
+ repl._rli.write( '\n' );
+ displayPrompt( repl, false );
+
+ debug( 'Loading a file...' );
+ repl.load( fpath );
+ }
+
+ /**
+ * Quits a REPL.
+ *
+ * @private
+ */
+ function onQuit() {
+ debug( 'Quitting the REPL...' );
+ repl.close();
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = createContext;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/create_require.js b/lib/node_modules/@stdlib/repl/ctor/lib/create_require.js
new file mode 100644
index 000000000000..39b85da0e607
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/create_require.js
@@ -0,0 +1,116 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+/*
+* WARNING: this is based an internal file within Node.js. The implementation uses private methods exposed on the `Module` object. Given that they are private, breakage is possible.
+*
+* [1]: https://github.com/nodejs/node/blob/0c1e93b9efadfc9fae74907a631908477c7d085e/lib/internal/modules/cjs/helpers.js#L10
+*/
+
+// MODULES //
+
+var Module = require( 'module' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+
+
+// VARIABLES //
+
+/* eslint-disable no-underscore-dangle */
+var resolveFilename = Module._resolveFilename;
+var resolveLookupPaths = Module._resolveLookupPaths;
+var extensions = Module._extensions;
+var cache = Module._cache;
+var main = process.mainModule;
+
+/* eslint-enable no-underscore-dangle */
+
+
+// MAIN //
+
+/**
+* Returns a `require` function.
+*
+* @private
+* @param {Module} module - module used as the context for `require`
+* @returns {Function} require function
+*/
+function createRequire( module ) {
+ /**
+ * Attempts to load a module.
+ *
+ * @private
+ * @param {string} path - module id
+ * @returns {*} module
+ */
+ function require( path ) {
+ return module.require( path );
+ }
+
+ /**
+ * Attempts to resolve a module.
+ *
+ * @private
+ * @param {string} name - module
+ * @param {Object} [options] - options
+ * @throws {TypeError} first argument must be a string
+ * @returns {string} module filepath
+ */
+ function resolve( name, options ) {
+ if ( !isString( name ) ) {
+ throw new TypeError( 'invalid argument. First argument must be a string. Value: `' + name + '`.' );
+ }
+ return resolveFilename( name, module, false, options );
+ }
+
+ /**
+ * Attempts to resolve look-up paths.
+ *
+ * @private
+ * @param {string} name - module
+ * @throws {TypeError} must provide a string
+ * @returns {(StringArray|null)} resolved paths
+ */
+ function paths( name ) {
+ if ( !isString( name ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + name + '`.' );
+ }
+ return resolveLookupPaths( name, module, true );
+ }
+
+ // Script entry point when Node.js process launched:
+ require.main = main;
+
+ // Attach method to resolve a module:
+ resolve.paths = paths;
+ require.resolve = resolve;
+
+ // Support for extra extension types:
+ require.extensions = extensions;
+
+ // Use the existing module cache:
+ require.cache = cache;
+
+ return require;
+}
+
+
+// EXPORTS //
+
+module.exports = createRequire;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/defaults.js b/lib/node_modules/@stdlib/repl/ctor/lib/defaults.js
new file mode 100644
index 000000000000..d1e6ed3ace66
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/defaults.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 stdin = require( '@stdlib/streams/node/stdin' );
+var stdout = require( '@stdlib/streams/node/stdout' );
+var WELCOME = require( './welcome_text.js' );
+
+
+// MAIN //
+
+/**
+* Returns default options.
+*
+* @private
+* @returns {Object} default options
+*
+* @example
+* var opts = defaults();
+* // returns {...}
+*/
+function defaults() {
+ return {
+ 'input': stdin,
+ 'output': stdout,
+ 'prompt': '> ',
+ 'isTTY': void 0,
+ 'sandbox': true,
+ 'welcome': WELCOME,
+ 'save': '',
+ 'load': ''
+ };
+}
+
+
+// EXPORTS //
+
+module.exports = defaults;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/display_prompt.js b/lib/node_modules/@stdlib/repl/ctor/lib/display_prompt.js
new file mode 100644
index 000000000000..3e625f98924c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/display_prompt.js
@@ -0,0 +1,47 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-underscore-dangle */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Displays a command prompt.
+*
+* @private
+* @param {REPL} repl - REPL instance
+* @param {boolean} [preserveCursor=false] - boolean indicating whether to preserve the cursor position
+*/
+function displayPrompt( repl, preserveCursor ) {
+ var prompt;
+ if ( repl._cmd.length ) {
+ // TODO: determine indentation level (use spaces)
+ prompt = '';
+ } else {
+ prompt = repl._prompt;
+ }
+ repl._rli.setPrompt( prompt );
+ repl._rli.prompt( preserveCursor );
+}
+
+
+// EXPORTS //
+
+module.exports = displayPrompt;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/drain.js b/lib/node_modules/@stdlib/repl/ctor/lib/drain.js
new file mode 100644
index 000000000000..768279c047df
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/drain.js
@@ -0,0 +1,155 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-underscore-dangle */
+
+'use strict';
+
+// MODULES //
+
+var inspect = require( 'util' ).inspect;
+var logger = require( 'debug' );
+var displayPrompt = require( './display_prompt.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:drain' );
+
+/*
+* In certain JavaScript engines (e.g., V8, SpiderMonkey), the global `RegExp` object has ([non-standard][1]) static, read-only properties (`$1`, `$2`, ..., `$9`) with cached substring matches. In order to preserve these matches between command evaluations, we need to capture and subsequently restore them prior to evaluation.
+*
+* [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/n
+*/
+var SEP_REGEXP_MATCHES = '\u0000\u0000\u0000';
+var RE_REGEXP_MATCHES = new RegExp( [ '^', '(.*)', '(.*)', '(.*)', '(.*)', '(.*)', '(.*)', '(.*)', '(.*)', '(.*)$' ].join( SEP_REGEXP_MATCHES ) );
+
+
+// FUNCTIONS //
+
+/**
+* Updates the cache of saved regular expression substring matches.
+*
+* @private
+* @param {StringArray} cache - list of previously saved substring matches
+* @returns {StringArray} cache
+*/
+function updateRegExpCache( cache ) {
+ var i;
+ for ( i = 1; i < cache.length; i++ ) {
+ cache[ i ] = RegExp[ '$'+i ];
+ }
+ return cache;
+}
+
+/**
+* Restores the (non-standard) properties on the `RegExp` expression object to the cached matches.
+*
+* @private
+* @param {StringArray} cache - list of previously saved substring matches
+*/
+function restoreRegExpMatches( cache ) {
+ RE_REGEXP_MATCHES.test( cache.join( SEP_REGEXP_MATCHES ) );
+}
+
+
+// MAIN //
+
+/**
+* Drains a REPL's command queue.
+*
+* @private
+* @param {REPL} repl - REPL instance
+* @returns {void}
+*/
+function drain( repl ) {
+ var opts;
+ var code;
+ var res;
+
+ if ( repl._queue.length === 0 ) {
+ debug( 'Command queue is empty.' );
+ repl._busy = false;
+ if ( !repl._closed ) {
+ displayPrompt( repl, false );
+ }
+ return;
+ }
+ if ( repl._busy ) {
+ debug( 'Waiting on an asynchronous command to finish...' );
+ return;
+ }
+ debug( 'Evaluating next command...' );
+
+ // Remove a command from the queue:
+ code = repl._queue.pop();
+ debug( 'Command: %s', code.raw );
+
+ // Set the (non-standard) properties on the `RegExp` expression object to the cached matches:
+ restoreRegExpMatches( repl._regexp );
+
+ // TODO: handle async processing (if `code.async`, set `busy` to true; otherwise, assume sync processing)
+
+ // TODO: evaluate and determine whether to print result
+ opts = {
+ 'displayErrors': false,
+ 'breakOnSigint': true // Note: only applies for Node.js versions >=6.3.0
+ };
+ try {
+ if ( repl._sandbox ) {
+ res = code.compiled.runInContext( repl._context, opts );
+ } else {
+ res = code.compiled.runInThisContext( opts );
+ }
+ updateRegExpCache( repl._regexp );
+ } catch ( error ) {
+ updateRegExpCache( repl._regexp );
+
+ // TODO: handle SIGINT (see https://github.com/nodejs/node/blob/b21e7c7bcf23a2715951e4cd96180e4dbf1dcd4d/lib/repl.js#L581)
+
+ // TODO: check if error is recoverable
+ debug( 'Error: %s', error.message );
+ repl._ostream.write( 'Error: '+error.message+'\n' );
+ displayPrompt( repl, false );
+ return;
+ }
+ if ( code.silent === false && res !== void 0 ) {
+ repl._ostream.write( inspect( res )+'\n' ); // TODO: pretty printing (can defer to `util.inspect` for now, but will invariably want more control over this later, possibly including default configuration, etc, either at startup, during runtime, or according to an external configuration file)
+ }
+ // Cache the result:
+ repl._ans = res;
+
+ // TODO: if successful, save the command in the history buffer and, if necessary, write to a history file
+
+ // TODO: replace with polyfill
+ process.nextTick( onTick );
+
+ /**
+ * Callback invoked upon the next tick of the event loop.
+ *
+ * @private
+ */
+ function onTick() {
+ drain( repl );
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = drain;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/globals.js b/lib/node_modules/@stdlib/repl/ctor/lib/globals.js
new file mode 100644
index 000000000000..fbd0f8a66e10
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/globals.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+// MAIN //
+
+// TODO: remove once we have stdlib pkg equivalents
+var GLOBALS = {
+ 'Array': Array,
+ 'Boolean': Boolean,
+ 'Date': Date,
+ 'Function': Function,
+ 'Object': Object,
+ 'parseFloat': parseFloat,
+ 'parseInt': parseInt,
+ 'RegExp': RegExp,
+ 'String': String,
+
+ // TODO: BigInt, DataView, Map, Set, Promise, Reflect(?), WeakMap, WeakSet, WebAssembly
+
+ 'Error': Error,
+ 'EvalError': EvalError,
+ 'RangeError': RangeError,
+ 'ReferenceError': ReferenceError,
+ 'SyntaxError': SyntaxError,
+ 'TypeError': TypeError,
+ 'URIError': URIError,
+
+ 'clearImmediate': clearImmediate,
+ 'clearInterval': clearInterval,
+ 'clearTimeout': clearTimeout,
+ 'setImmediate': setImmediate,
+ 'setInterval': setInterval,
+ 'setTimeout': setTimeout
+};
+
+
+// EXPORTS //
+
+module.exports = GLOBALS;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/help_text.js b/lib/node_modules/@stdlib/repl/ctor/lib/help_text.js
new file mode 100644
index 000000000000..6e4a9175a5e5
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/help_text.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+// MAIN //
+
+var MSG = [
+ '',
+ ' help() Prints help text.',
+ ' help( alias ) Prints help text for a specified alias.',
+ ' help( alias. ) Prints help text for a specified property.',
+ '',
+ ' example( alias ) Runs examples for a specified alias.',
+ ' example( alias. ) Runs examples for a specified property.',
+ '',
+ ' load( fpath ) Loads and evaluates a JavaScript file line-by-line.',
+ ' save( fpath ) Saves previous commands to a specified file.',
+ ' saveStart( fpath ) Start saving commands to a specified file.',
+ ' saveStop( id ) Stop saving commands.',
+ '',
+ ' clear() Clears the REPL context.',
+ ' quit() Exits the REPL.',
+ '',
+ ' aliases() Lists namespace contents.',
+ ' alias2pkg( alias ) Converts an alias to a stdlib package name.',
+ ' pkg2alias( pkg ) Converts a stdlib package name to an alias.',
+ ' alias2related( alias ) Lists related aliases.',
+ ' pkg2related( pkg ) Lists related package names.',
+ ' isKeyword( value ) Asserts whether a value is a reserved keyword/alias.',
+ '',
+ ' citation() Prints how to cite stdlib in publications.',
+ ' license() Prints license information.',
+ ' copyright() Prints copyright information.',
+ ' contributors() Lists contributors.',
+ ' credits() Prints credits.',
+ ' donate() Prints donation information.',
+ '',
+ ''
+].join( '\n' );
+
+
+// EXPORTS //
+
+module.exports = MSG;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/index.js b/lib/node_modules/@stdlib/repl/ctor/lib/index.js
new file mode 100644
index 000000000000..e0e338005374
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/index.js
@@ -0,0 +1,39 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+/**
+* REPL environment.
+*
+* @module @stdlib/repl/ctor
+*
+* @example
+* var REPL = require( '@stdlib/repl/ctor' );
+*
+* // TODO
+*/
+
+// MODULES //
+
+var REPL = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = REPL;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/index_of.js b/lib/node_modules/@stdlib/repl/ctor/lib/index_of.js
new file mode 100644
index 000000000000..5dce20f09d70
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/index_of.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+// MAIN //
+
+/**
+* Searches a strided array-like object for a search value.
+*
+* @private
+* @param {NonNegativeInteger} N - number of elements to search
+* @param {ArrayLike} arr - array to search
+* @param {integer} stride - index stride
+* @param {NonNegativeInteger} offset - index offset
+* @param {*} value - search value
+* @returns {integer} search value index
+*
+* @example
+* var arr = [ 1, 2, 3 ];
+*
+* var bool = indexOf( arr.length, arr, 1, 0, 2 );
+* // returns 1
+*
+* bool = indexOf( arr.length, arr, 1, 0, 4 );
+* // returns -1
+*/
+function indexOf( N, arr, stride, offset, value ) {
+ var idx;
+ var i;
+
+ idx = offset;
+ for ( i = 0; i < N; i++ ) {
+ if ( arr[ idx ] === value ) {
+ return idx;
+ }
+ idx += stride;
+ }
+ return -1;
+}
+
+
+// EXPORTS //
+
+module.exports = indexOf;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/main.js b/lib/node_modules/@stdlib/repl/ctor/lib/main.js
new file mode 100644
index 000000000000..0a0cbcf0f2d9
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/main.js
@@ -0,0 +1,323 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-restricted-syntax, no-invalid-this, no-underscore-dangle */
+
+'use strict';
+
+// MODULES //
+
+var EventEmitter = require( 'events' ).EventEmitter;
+var readline = require( 'readline' ).createInterface;
+var resolve = require( 'path' ).resolve;
+var logger = require( 'debug' );
+var inherit = require( '@stdlib/utils/inherit' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var setNonEnumerable = require( '@stdlib/utils/define-nonenumerable-property' );
+var setNonEnumerableReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var cwd = require( '@stdlib/process/cwd' );
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var RE_EOL = require( '@stdlib/regexp/eol' );
+var fifo = require( '@stdlib/utils/fifo' );
+var validate = require( './validate.js' );
+var defaults = require( './defaults.js' );
+var displayPrompt = require( './display_prompt.js' );
+var createContext = require( './create_context.js' );
+var processLine = require( './process_line.js' );
+var clear = require( './clear.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl' );
+
+
+// MAIN //
+
+/**
+* REPL constructor.
+*
+* @constructor
+* @param {Options} options - constructor options
+* @param {string} [options.prompt='> '] - input prompt
+* @param {ReadableStream} [options.input=process.stdin] - input stream
+* @param {WritableStream} [options.output=process.stdout] - output stream
+* @param {boolean} [options.sandbox=true] - boolean indicating whether to run a REPL in a sandboxed context
+* @param {boolean} [options.isTTY] - boolean indicating whether the input and output streams should be treated like a TTY (terminal) and whether the REPL should use ANSI/VT100 escape codes when writing to the output stream
+* @param {string} [options.welcome] - welcome message
+* @param {string} [options.load] - file path specifying a JavaScript file to load and evaluate line-by-line (e.g., a previous REPL history file)
+* @param {string} [options.save] - file path specifying where to save REPL history
+* @throws {Error} must provide valid options
+* @returns {REPL} REPL instance
+*
+* @example
+* // TODO
+*/
+function REPL( options ) {
+ var opts;
+ var self;
+ var err;
+
+ if ( !( this instanceof REPL ) ) {
+ if ( arguments.length ) {
+ return new REPL( options );
+ }
+ return new REPL();
+ }
+ self = this;
+
+ opts = defaults();
+ if ( arguments.length ) {
+ err = validate( opts, options );
+ if ( err ) {
+ throw err;
+ }
+ }
+ opts.isTTY = ( opts.isTTY === void 0 ) ? opts.output.isTTY : opts.isTTY;
+
+ debug( 'Options: %s', JSON.stringify({
+ 'input': '',
+ 'output': '',
+ 'sandbox': opts.sandbox,
+ 'isTTY': opts.isTTY,
+ 'prompt': opts.prompt,
+ 'welcome': opts.welcome,
+ 'load': opts.load,
+ 'save': opts.save
+ }));
+
+ // Call the parent constructor:
+ EventEmitter.call( this );
+
+ // Cache references to the input and output streams:
+ setNonEnumerableReadOnly( this, '_istream', opts.input );
+ setNonEnumerableReadOnly( this, '_ostream', opts.output );
+
+ // Cache options:
+ setNonEnumerableReadOnly( this, '_prompt', opts.prompt );
+ setNonEnumerableReadOnly( this, '_isTTY', opts.isTTY );
+ setNonEnumerableReadOnly( this, '_sandbox', opts.sandbox );
+
+ // Initialize an internal command queue:
+ setNonEnumerableReadOnly( this, '_queue', fifo() );
+
+ // Initialize an internal buffer for storing the command history:
+ setNonEnumerableReadOnly( this, '_history', [] );
+
+ // Initialize an internal buffer for storing the current command:
+ setNonEnumerableReadOnly( this, '_cmd', [] );
+
+ // Initialize an internal buffer for saving regular expression matches between command evaluations:
+ setNonEnumerableReadOnly( this, '_regexp', [ '', '', '', '', '', '', '', '', '', '' ] );
+
+ // For non-sandboxed REPLs, initialize an internal buffer for storing a list of global variables/properties which need to be deleted upon closing a REPL in order to allow garbage collection and prevent memory leaks:
+ setNonEnumerableReadOnly( this, '_globalVars', ( this._sandbox ) ? null : [] );
+
+ // Initialize a strided internal cache of resolved global variables/properties in order to allow, e.g., help text look-up based on object reference, not just alias name (note: members alternate between `''` and ``):
+ setNonEnumerableReadOnly( this, '_aliases', [] );
+
+ // Initialize an internal flag indicating whether the REPL has been closed:
+ setNonEnumerable( this, '_closed', false );
+
+ // Initialize an internal flag indicating whether the REPL is currently busy with asynchronous processing:
+ setNonEnumerable( this, '_busy', false );
+
+ // Initialize an internal variable for caching the result of the last successfully evaluated command:
+ setNonEnumerable( this, '_ans', void 0 );
+
+ // Create an internal readline interface:
+ debug( 'Creating readline interface...' );
+ setNonEnumerableReadOnly( this, '_rli', readline({
+ 'input': this._istream,
+ 'output': this._ostream,
+ 'terminal': opts.isTTY,
+ 'prompt': opts.prompt
+ }));
+ this._rli.on( 'close', onClose );
+ this._rli.on( 'line', onLine );
+
+ // Create a REPL execution context:
+ setNonEnumerable( this, '_context', createContext( this ) );
+
+ // Write a welcome message:
+ this._ostream.write( opts.welcome );
+
+ // TODO: check whether to synchronously initialize a REPL history file
+
+ // Check whether to load and execute a JavaScript file (e.g., prior REPL history) upon startup...
+ if ( opts.load ) {
+ this.load( opts.load );
+ } else {
+ displayPrompt( this, false );
+ }
+ return this;
+
+ /**
+ * Callback invoked upon a readline interface "line" event.
+ *
+ * @private
+ * @param {string} line - line data
+ */
+ function onLine( line ) {
+ if ( self._closed === false ) {
+ processLine( self, line );
+ }
+ }
+
+ /**
+ * Callback invoked upon a readline interface "close" event.
+ *
+ * @private
+ */
+ function onClose() {
+ debug( 'Readline interface closed.' );
+ debug( 'Exiting REPL...' );
+ self.emit( 'exit' );
+ }
+}
+
+/*
+* Inherit from the `EventEmitter` prototype.
+*/
+inherit( REPL, EventEmitter );
+
+/**
+* Loads and evaluates a JavaScript file line-by-line.
+*
+* ## Notes
+*
+* - The method **synchronously** reads provided files in order to preserve command order.
+*
+* @name load
+* @memberof REPL.prototype
+* @type {Function}
+* @param {string} fpath - file path
+* @throws {Error} cannot load a file into a closed REPL
+* @throws {TypeError} must provide a string
+* @returns {REPL} REPL instance
+*/
+setNonEnumerableReadOnly( REPL.prototype, 'load', function load( fpath ) {
+ var file;
+ var i;
+ if ( this._closed ) {
+ throw new Error( 'invalid operation. Cannot load a file into a REPL which has already closed.' );
+ }
+ if ( !isString( fpath ) ) {
+ throw new TypeError( 'invalid argument. Must provide a string. Value: `' + fpath + '`.' );
+ }
+ // Resolve the provided path to an absolute file path:
+ fpath = resolve( cwd(), fpath );
+ debug( 'Loading filepath: %s', fpath );
+
+ // Attempt to synchronously read the file:
+ file = readFileSync( fpath, 'utf8' );
+ if ( file instanceof Error ) {
+ debug( 'Error: %s', file.message );
+ this._ostream.write( 'Error: '+file.message+'\n' );
+ return this;
+ }
+ // Split the file content into individual lines:
+ file = file.split( RE_EOL );
+
+ // Forward each line to the REPL readline interface in order to mimic user input...
+ for ( i = 0; i < file.length; i++ ) {
+ if ( file[ i ] ) {
+ this._rli.write( file[ i ]+'\n' );
+ displayPrompt( this, false );
+ }
+ }
+ return this;
+});
+
+/**
+* Clears a REPL's local context.
+*
+* @name clear
+* @memberof REPL.prototype
+* @type {Function}
+* @throws {Error} cannot clear a closed REPL
+* @returns {REPL} REPL instance
+*/
+setNonEnumerableReadOnly( REPL.prototype, 'clear', function onClear() {
+ if ( this._closed ) {
+ throw new Error( 'invalid operation. Cannot clear a REPL which has already closed.' );
+ }
+ clear( this );
+ return this;
+});
+
+/**
+* Closes a REPL.
+*
+* @name close
+* @memberof REPL.prototype
+* @type {Function}
+* @returns {REPL} REPL instance
+*/
+setNonEnumerableReadOnly( REPL.prototype, 'close', function close() {
+ var self;
+ if ( this._closed ) {
+ debug( 'Attempted to close an already closed REPL.' );
+ return this;
+ }
+ self = this;
+ this._closed = true;
+
+ // Clear the command queue:
+ this._queue.clear();
+
+ // TODO: ensure REPL history is saved (flushed) to file before closing the REPL (see https://github.com/nodejs/node/blob/b21e7c7bcf23a2715951e4cd96180e4dbf1dcd4d/lib/repl.js#L805)
+
+ // TODO: replace with polyfill
+ process.nextTick( onTick );
+
+ return this;
+
+ /**
+ * Callback invoked upon the next tick of the event loop.
+ *
+ * @private
+ */
+ function onTick() {
+ var key;
+ var o;
+ var i;
+ var j;
+
+ debug( 'Closing readline interface...' );
+ self._rli.close();
+
+ // If this is a non-sandboxed REPL, remove global variables/properties which were introduced during context creation...
+ if ( self._sandbox === false ) {
+ for ( i = 0; i < self._globalVars.length; i++ ) {
+ o = self._context;
+ key = self._globalVars[ i ].split( '.' ); // Note: this addresses nested key paths (e.g., `a.b.c`)
+ for ( j = 0; j < key.length-1; j++ ) {
+ o = o[ key[ j ] ];
+ }
+ delete o[ key[ j ] ];
+ }
+ self._globalVars.length = 0;
+ }
+ }
+});
+
+
+// EXPORTS //
+
+module.exports = REPL;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/process_line.js b/lib/node_modules/@stdlib/repl/ctor/lib/process_line.js
new file mode 100644
index 000000000000..1d3656059d0d
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/process_line.js
@@ -0,0 +1,120 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 no-underscore-dangle */
+
+'use strict';
+
+// MODULES //
+
+var vm = require( 'vm' );
+var logger = require( 'debug' );
+var trim = require( '@stdlib/string/trim' );
+var displayPrompt = require( './display_prompt.js' );
+var drain = require( './drain.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:line' );
+var SEMICOLON = 59; // character code
+var RE_OPENING_BRACE = /^\s*\{/;
+var RE_CLOSING_BRACE = /\}\s*$/;
+var RE_WHITESPACE = /^\s*$/;
+
+
+// MAIN //
+
+/**
+* Processes input line data.
+*
+* @private
+* @param {REPL} repl - REPL instance
+* @param {string} line - line data
+* @returns {void}
+*/
+function processLine( repl, line ) {
+ var isWrapped;
+ var script;
+ var opts;
+ var code;
+
+ debug( 'Line: %s', line );
+
+ // Removing leading and trailing whitespace:
+ line = trim( line );
+
+ // TODO: check if the line is valid JavaScript syntax; if yes, then proceed; otherwise, buffer the command in `cmd` buffer until ready to execute (e.g., when providing multi-line input)
+
+ opts = {
+ 'filename': '',
+ 'lineOffset': 0
+ };
+ code = {
+ 'raw': line
+ };
+
+ // Check for commands like object literals (e.g., `{'a':1}`), which we want to be evaluated as expressions, rather than blocks...
+ if ( RE_OPENING_BRACE.test( line ) && RE_CLOSING_BRACE.test( line ) ) {
+ // FIXME: we need to actually parse into an AST here and check if the last "expression" begins and ends with braces (e.g., `1+1; {'a':1}`); if so, we need to wrap the last expression in parentheses
+ // FIXME: the above also fails to account for `{'a':1};`, which ends in a semicolon and not a brace
+ // FIXME: the above also fails to account for expressions such as variable assignments (e.g., `var v = [1,2,3]`), where we may want to see the assigned value
+ line = '(' + line + ')\n';
+ isWrapped = true;
+ }
+ // TODO: check whether line begins with (or includes?) `await` or `for await` (the latter would allow for updating the last line of output; e.g., an ASCII chart!); if async processing, then will need to transform the source code so that the returned promise is wrapped in order to invoke a callback/hook to indicate completion and a readiness to continue draining
+ code.async = false;
+
+ // Attempt to compile the command...
+ while ( true ) {
+ try {
+ if ( RE_WHITESPACE.test( line ) ) {
+ script = new vm.Script( line, opts );
+ code.silent = true;
+ } else {
+ // Note: `void 0` ensures that the compiled script does not return the string `'use strict'` when provided commands (statements/declarations) which do not return a value (e.g., `{}`):
+ script = new vm.Script( '\'use strict\'; void 0;\n'+line, opts );
+ code.silent = line.charCodeAt( line.length-1 ) === SEMICOLON;
+ }
+ code.compiled = script;
+ } catch ( error ) {
+ // If we previously wrapped the command, unwrap and try again...
+ if ( isWrapped ) {
+ isWrapped = false;
+ line = code.raw;
+ continue;
+ }
+ // TODO: check if error is recoverable? And if so, update the command buffer; otherwise, write error message to console and display prompt.
+ debug( 'Error: %s', error.message );
+ repl._ostream.write( 'Error: '+error.message+'\n' );
+ displayPrompt( repl, false );
+ return;
+ }
+ break;
+ }
+ // Add the command to the command queue:
+ repl._queue.push( code );
+
+ // Request to run the command:
+ drain( repl );
+}
+
+
+// EXPORTS //
+
+module.exports = processLine;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases.js b/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases.js
new file mode 100644
index 000000000000..c67e86dfd394
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases.js
@@ -0,0 +1,77 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var setReadOnly = require( '@stdlib/utils/define-read-only-property' );
+var setMemoizedReadOnly = require( '@stdlib/utils/define-memoized-read-only-property' );
+var contains = require( './contains.js' );
+var createAccessor = require( './create_accessor.js' );
+var ALIASES = require( './aliases.js' );
+
+
+// MAIN //
+
+/**
+* Sets aliases on a sandboxed `context` object.
+*
+* @private
+* @param {Array} out - strided output array for storing resolved module exports
+* @param {Object} context - context object
+* @param {Array} skip - list of aliases to skip
+* @returns {Object} context object
+*/
+function setAliases( out, context, skip ) {
+ var alias;
+ var key;
+ var N;
+ var o;
+ var i;
+ var j;
+ var k;
+
+ N = skip.length;
+
+ // Extend the context object, keeping in mind that an alias may be nested (e.g., `a.b.c`), and, if so, we need to recursively generate nested objects...
+ for ( i = 0; i < ALIASES.length; i++ ) {
+ alias = ALIASES[ i ];
+ if ( contains( N, skip, 1, 0, alias ) ) {
+ continue;
+ }
+ o = context;
+ key = alias.split( '.' );
+ for ( j = 0; j < key.length-1; j++ ) {
+ k = key[ j ];
+ if ( !hasOwnProp( o, k ) ) {
+ setReadOnly( o, k, {} );
+ }
+ o = o[ k ];
+ }
+ k = key[ j ];
+ setMemoizedReadOnly( o, k, createAccessor( out, context.require, alias ) ); // eslint-disable-line max-len
+ }
+ return context;
+}
+
+
+// EXPORTS //
+
+module.exports = setAliases;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases_global.js b/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases_global.js
new file mode 100644
index 000000000000..259f56c0db9a
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/set_aliases_global.js
@@ -0,0 +1,104 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 logger = require( 'debug' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var setReadOnly = require( '@stdlib/utils/define-read-only-property' );
+var setMemoizedReadOnly = require( '@stdlib/utils/define-memoized-read-only-property' );
+var contains = require( './contains.js' );
+var createAccessor = require( './create_accessor.js' );
+var ALIASES = require( './aliases.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:set_aliases' );
+
+
+// MAIN //
+
+/**
+* Sets aliases on a non-sandboxed `context` object.
+*
+* ## Notes
+*
+* - This function avoids overwriting properties in a non-sandboxed environment in order to avoid unintended side-effects.
+*
+* @private
+* @param {Array} out1 - output array for storing a list of global variables added to the global namespace
+* @param {Array} out2 - strided output array for storing resolved module exports
+* @param {Object} context - context object
+* @param {Array} skip - list of aliases to skip
+* @returns {Object} context object
+*/
+function setAliasesGlobal( out1, out2, context, skip ) {
+ var alias;
+ var key;
+ var FLG;
+ var N;
+ var o;
+ var i;
+ var j;
+ var k;
+
+ N = skip.length;
+
+ // Extend the context object, keeping in mind that an alias may be nested (e.g., `a.b.c`), and, if so, we need to generate nested objects...
+ for ( i = 0; i < ALIASES.length; i++ ) {
+ alias = ALIASES[ i ];
+ if ( contains( N, skip, 1, 0, alias ) ) {
+ continue;
+ }
+ o = context;
+ FLG = false;
+ key = alias.split( '.' );
+ for ( j = 0; j < key.length-1; j++ ) {
+ k = key[ j ];
+ if ( !hasOwnProp( o, k ) ) {
+ // Upon first encountering a new property, we need to remember the current key path, so that we can later remove the properties upon closing the REPL...
+ if ( FLG === false ) {
+ FLG = true;
+ out1.push( key.slice( 0, j+1 ).join( '.' ) );
+ }
+ setReadOnly( o, k, {} );
+ }
+ o = o[ k ];
+ }
+ k = key[ j ];
+
+ // Avoid overwriting properties in a non-sandboxed environment in order to avoid unintended side-effects (e.g., don't break an already running application which has already defined a particular global variable)...
+ if ( hasOwnProp( o, k ) ) {
+ debug( 'Skipping alias as global context property `'+alias+'` is already assigned.' );
+ } else {
+ if ( FLG === false ) {
+ out1.push( alias );
+ }
+ setMemoizedReadOnly( o, k, createAccessor( out2, context.require, alias ) ); // eslint-disable-line max-len
+ }
+ }
+ return context;
+}
+
+
+// EXPORTS //
+
+module.exports = setAliasesGlobal;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/set_commands.js b/lib/node_modules/@stdlib/repl/ctor/lib/set_commands.js
new file mode 100644
index 000000000000..ff01369ddfd3
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/set_commands.js
@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 setReadOnly = require( '@stdlib/utils/define-read-only-property' );
+var setReadOnlyAccessor = require( '@stdlib/utils/define-read-only-accessor' );
+
+
+// MAIN //
+
+/**
+* Sets commands on a sandboxed `context` object.
+*
+* @private
+* @param {Object} context - context object
+* @param {ArrayArray} commands - commands
+* @returns {Object} context object
+*/
+function setCommands( context, commands ) {
+ var cmd;
+ var i;
+
+ for ( i = 0; i < commands.length; i++ ) {
+ cmd = commands[ i ];
+ if ( cmd[ 2 ] ) {
+ setReadOnlyAccessor( context, cmd[ 0 ], cmd[ 1 ] );
+ } else {
+ setReadOnly( context, cmd[ 0 ], cmd[ 1 ] );
+ }
+ }
+ return context;
+}
+
+
+// EXPORTS //
+
+module.exports = setCommands;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/set_commands_global.js b/lib/node_modules/@stdlib/repl/ctor/lib/set_commands_global.js
new file mode 100644
index 000000000000..04d61b0a0d4c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/set_commands_global.js
@@ -0,0 +1,72 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 logger = require( 'debug' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var setConfigurableReadOnly = require( '@stdlib/utils/define-configurable-read-only-property' );
+var setConfigurableReadOnlyAccessor = require( '@stdlib/utils/define-configurable-read-only-accessor' ); // eslint-disable-line id-length
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:set_commands' );
+
+
+// MAIN //
+
+/**
+* Sets commands on non-sandboxed `context` object.
+*
+* ## Notes
+*
+* - This function avoids overwriting properties in a non-sandboxed environment in order to avoid unintended side-effects.
+*
+* @private
+* @param {Array} out - output array for storing a list of global variables added to the global namespace
+* @param {Object} context - context object
+* @param {ArrayArray} commands - commands
+* @returns {Object} context object
+*/
+function setCommandsGlobal( out, context, commands ) {
+ var cmd;
+ var i;
+
+ for ( i = 0; i < commands.length; i++ ) {
+ cmd = commands[ i ];
+ if ( hasOwnProp( context, cmd[ 0 ] ) ) {
+ debug( 'Skipping command as global context property `'+cmd[0]+'` is already assigned.' );
+ } else {
+ out.push( cmd[ 0 ] );
+ if ( cmd[ 2 ] ) {
+ setConfigurableReadOnlyAccessor( context, cmd[ 0 ], cmd[ 1 ] );
+ } else {
+ setConfigurableReadOnly( context, cmd[ 0 ], cmd[ 1 ] );
+ }
+ }
+ }
+ return context;
+}
+
+
+// EXPORTS //
+
+module.exports = setCommandsGlobal;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/validate.js b/lib/node_modules/@stdlib/repl/ctor/lib/validate.js
new file mode 100644
index 000000000000..e51ed295288a
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/validate.js
@@ -0,0 +1,116 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 isReadableStreamLike = require( '@stdlib/assert/is-node-readable-stream-like' );
+var isWritableStreamLike = require( '@stdlib/assert/is-node-writable-stream-like' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var isBoolean = require( '@stdlib/assert/is-boolean' ).isPrimitive;
+
+
+// MAIN //
+
+/**
+* Validates function options.
+*
+* @private
+* @param {Object} opts - destination object
+* @param {Options} options - function options
+* @param {string} [options.prompt] - input prompt
+* @param {ReadableStream} [options.input=] - input stream
+* @param {WritableStream} [options.output] - output stream
+* @param {boolean} [options.sandbox] - boolean indicating whether to run a REPL in a sandboxed context
+* @param {boolean} [options.isTTY] - boolean indicating whether the input and output streams should be treated like a TTY (terminal) and whether the REPL should use ANSI/VT100 escape codes when writing to the output stream
+* @param {string} [options.welcome] - welcome message
+* @param {string} [options.load] - file path specifying a JavaScript file to load and evaluate line-by-line (e.g., a previous REPL history file)
+* @param {string} [options.save] - file path specifying where to save REPL history
+* @throws {Error} must provide valid options
+* @returns {(Error|null)} error or null
+*
+* @example
+* var options = {};
+* var opts = {};
+* var err = validate( opts, options );
+* if ( err ) {
+* throw err;
+* }
+*/
+function validate( opts, options ) {
+ if ( !isPlainObject( options ) ) {
+ return new TypeError( 'invalid argument. Options argument must be an object. Value: `' + options + '`.' );
+ }
+ if ( hasOwnProp( options, 'input' ) ) {
+ opts.input = options.input;
+ if ( !isReadableStreamLike( options.input ) ) {
+ return new TypeError( 'invalid option. `input` option must be a readable stream. Option: `' + options.input + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'output' ) ) {
+ opts.output = options.output;
+ if ( !isWritableStreamLike( options.output ) ) {
+ return new TypeError( 'invalid option. `output` option must be a writable stream. Option: `' + options.output + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'prompt' ) ) {
+ opts.prompt = options.prompt;
+ if ( !isString( options.prompt ) ) {
+ return new TypeError( 'invalid option. `prompt` option must be a string. Option: `' + options.prompt + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'welcome' ) ) {
+ opts.welcome = options.welcome;
+ if ( !isString( options.welcome ) ) {
+ return new TypeError( 'invalid option. `welcome` option must be a string. Option: `' + options.welcome + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'save' ) ) {
+ opts.save = options.save;
+ if ( !isString( options.save ) ) {
+ return new TypeError( 'invalid option. `save` option must be a string. Option: `' + options.save + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'load' ) ) {
+ opts.load = options.load;
+ if ( !isString( options.load ) ) {
+ return new TypeError( 'invalid option. `load` option must be a string. Option: `' + options.load + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'isTTY' ) ) {
+ opts.isTTY = options.isTTY;
+ if ( !isBoolean( options.isTTY ) ) {
+ return new TypeError( 'invalid option. `isTTY` option must be a boolean. Option: `' + options.isTTY + '`.' );
+ }
+ }
+ if ( hasOwnProp( options, 'sandbox' ) ) {
+ opts.sandbox = options.sandbox;
+ if ( !isBoolean( options.sandbox ) ) {
+ return new TypeError( 'invalid option. `sandbox` option must be a boolean. Option: `' + options.sandbox + '`.' );
+ }
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = validate;
diff --git a/lib/node_modules/@stdlib/repl/ctor/lib/welcome_text.js b/lib/node_modules/@stdlib/repl/ctor/lib/welcome_text.js
new file mode 100644
index 000000000000..7ef8c295678c
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/lib/welcome_text.js
@@ -0,0 +1,52 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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';
+
+// MAIN //
+
+var MSG = [
+ '',
+ 'A better REPL for JavaScript and Node.js.',
+
+ // TODO: include platform, copyright, version (see Julia, R, and Python for inspiration)
+ '',
+ ' help() Prints help text.',
+ ' help( alias ) Prints help text for a specified alias.',
+ ' help( alias. ) Prints help text for a specified property.',
+ '',
+ ' example( alias ) Runs examples for a specified alias.',
+ ' example( alias. ) Runs examples for a specified property.',
+ '',
+ ' clear() Clears the list of previous commands.',
+ ' quit() Exits the REPL.',
+ '',
+ ' license() Prints license information.',
+ ' copyright() Prints copyright information.',
+ '',
+ 'For more info about stdlib, see the source repository:',
+ '',
+ ' https://github.com/stdlib-js/stdlib',
+ '',
+ ''
+].join( '\n' );
+
+
+// EXPORTS //
+
+module.exports = MSG;
diff --git a/lib/node_modules/@stdlib/repl/ctor/package.json b/lib/node_modules/@stdlib/repl/ctor/package.json
new file mode 100644
index 000000000000..0f9c446c0100
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/ctor/package.json
@@ -0,0 +1,72 @@
+{
+ "name": "@stdlib/repl/ctor",
+ "version": "0.0.0",
+ "description": "REPL environment.",
+ "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"
+ }
+ ],
+ "bin": {
+ "stdlib-repl-server": "./bin/cli"
+ },
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "bin": "./bin",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "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",
+ "repl",
+ "read-eval-print-loop",
+ "eval",
+ "evaluate",
+ "interact",
+ "interactive",
+ "console",
+ "terminal",
+ "shell",
+ "server"
+ ],
+ "__stdlib__": {
+ "envs": {
+ "browser": false
+ }
+ }
+}
diff --git a/lib/node_modules/@stdlib/repl/help/LICENSE b/lib/node_modules/@stdlib/repl/help/LICENSE
new file mode 100644
index 000000000000..dc6d53e33997
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/help/LICENSE
@@ -0,0 +1,356 @@
+The use of the database is licensed under an Open Data Commons Public Domain
+Dedication & License 1.0 (PDDL 1.0), while the database contents are licensed
+under Creative Commons Zero v1.0 Universal (CC0 1.0). The software is licensed
+under an Apache-2.0 license.
+
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+
+
+Creative Commons Zero v1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
+
+the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
+moral rights retained by the original author(s) and/or performer(s);
+publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
+rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
+rights protecting the extraction, dissemination, use and reuse of data in a Work;
+database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
+other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
+2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
+Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
+Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
+Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
+
+
+
+
+Open Data Commons Public Domain Dedication & License 1.0
+
+Preamble
+
+The Open Data Commons – Public Domain Dedication & Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents ("data"), either together or individually.
+
+Many databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the "sui generis" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a "some rights reserved" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.
+
+The position of the recipient of the work
+
+Because this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.
+
+The position of the dedicator of the work
+
+Copyright law, as with most other law under the banner of "intellectual property", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.
+
+The purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to "dual license" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can’t re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.
+
+This document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content – not just factual data – rightsholders should use the Open Data Commons – Public Domain Dedication & Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.
+
+Rightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the "Work", which can be either – or both – the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.
+
+Just like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.
+
+This document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.
+
+Part I: Introduction
+
+The Rightsholder (the Person holding rights or claims over the Work) agrees as follows:
+
+1.0 Definitions of Capitalised Words
+
+"Copyright" – Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.
+
+"Data" – The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.
+
+"Database" – A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.
+
+"Database Right" – Means rights over Data resulting from the Chapter III ("sui generis") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.
+
+"Document" – means this relinquishment and waiver of rights and claims and back up licence agreement.
+
+"Person" – Means a natural or legal person or a body of persons corporate or incorporate.
+
+"Use" – As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.
+
+"Work" – Means either or both of the Database and Data offered under the terms of this Document.
+
+"You" – the Person acquiring rights under the licence elements of this Document.
+
+Words in the singular include the plural and vice versa.
+
+2.0 What this document covers
+
+2.1. Legal effect of this Document. This Document is:
+
+a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and
+
+b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.
+
+2.2. Legal rights covered.
+
+a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and
+
+b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.
+
+2.2 Rights not covered.
+
+a. This Document does not apply to computer programs used in the making or operation of the Database;
+
+b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and
+
+c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.
+
+Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.
+
+Part II: Dedication to the public domain
+
+3.0 Dedication, waiver, and licence of Copyright and Database Rights
+
+3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.
+
+a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.
+
+b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.
+
+The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.
+
+3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:
+
+a. Copyright; and
+
+b. Database Rights.
+
+To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.
+
+3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:
+
+a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.
+
+3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author’s honour and reputation, or any other derogatory treatment:
+
+a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;
+
+b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and
+
+c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.
+
+Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.
+
+4.0 Relationship to other rights
+
+4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.
+
+4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.
+
+4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences. Part III: General provisions
+
+5.0 Warranties, disclaimer, and limitation of liability
+
+5.1 The Work is provided by the Rightsholder "as is" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.
+
+5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.
+
+5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.
+
+6.0 General
+
+6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms of this Document.
+
+6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.
+
+6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.
+
+6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document.
diff --git a/lib/node_modules/@stdlib/repl/help/README.md b/lib/node_modules/@stdlib/repl/help/README.md
index 73c8d03a89b9..6c14451cec58 100644
--- a/lib/node_modules/@stdlib/repl/help/README.md
+++ b/lib/node_modules/@stdlib/repl/help/README.md
@@ -2,7 +2,7 @@
@license Apache-2.0
-Copyright (c) 2018 The Stdlib Authors.
+Copyright (c) 2019 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.
@@ -20,7 +20,7 @@ limitations under the License.
# Help
-> REPL help texts.
+> Return help text associated with a provided alias.
@@ -40,13 +40,20 @@ limitations under the License.
var help = require( '@stdlib/repl/help' );
```
-#### help()
+#### help( alias )
-Returns an `object` containing REPL help texts.
+Returns help text for a provided alias.
```javascript
-var o = help();
-// returns {...}
+var txt = help( 'base.sin' );
+// returns
+```
+
+If provided an unrecognized `alias`, the function returns `null`.
+
+```javascript
+var txt = help( 'unrecognized_alias_beep_boop_bop_bip' );
+// returns null
```
@@ -72,17 +79,81 @@ var o = help();
```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var aliases = require( '@stdlib/namespace/aliases' );
var help = require( '@stdlib/repl/help' );
-var o = help();
-console.log( o );
-// => {...}
+var list;
+var len;
+var idx;
+var i;
+
+list = aliases();
+len = list.length;
+
+for ( i = 0; i < 100; i++ ) {
+ idx = discreteUniform( 0, len-1 );
+ console.log( help( list[ idx ] ) );
+}
```
+
+
+* * *
+
+
+
+## CLI
+
+
+
+
+
+### Usage
+
+```text
+Usage: stdlib-alias-help [options]
+
+Options:
+
+ -h, --help Print this message.
+ -V, --version Print the package version.
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```bash
+$ stdlib-alias-help 'base.sin'
+```
+
+
+
+
+
+
+
+
+
@@ -91,10 +162,24 @@ console.log( o );
+
+
+## License
+
+The data files (databases) are licensed under an [Open Data Commons Public Domain Dedication & License 1.0][pddl-1.0] and their contents are licensed under [Creative Commons Zero v1.0 Universal][cc0]. The software is licensed under [Apache License, Version 2.0][apache-license].
+
+
+
+[pddl-1.0]: http://opendatacommons.org/licenses/pddl/1.0/
+
+[cc0]: https://creativecommons.org/publicdomain/zero/1.0
+
+[apache-license]: https://www.apache.org/licenses/LICENSE-2.0
+
diff --git a/lib/node_modules/@stdlib/repl/help/benchmark/benchmark.js b/lib/node_modules/@stdlib/repl/help/benchmark/benchmark.js
index f7df0f6871c0..d7645f61424c 100644
--- a/lib/node_modules/@stdlib/repl/help/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/repl/help/benchmark/benchmark.js
@@ -1,7 +1,7 @@
/**
* @license Apache-2.0
*
-* Copyright (c) 2018 The Stdlib Authors.
+* Copyright (c) 2019 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.
@@ -21,7 +21,8 @@
// MODULES //
var bench = require( '@stdlib/bench' );
-var isPlainObject = require( '@stdlib/assert/is-plain-object' );
+var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
+var aliases = require( '@stdlib/namespace/aliases' );
var pkg = require( './../package.json' ).name;
var help = require( './../lib' );
@@ -29,18 +30,22 @@ var help = require( './../lib' );
// MAIN //
bench( pkg, function benchmark( b ) {
- var o;
+ var values;
+ var v;
var i;
+
+ values = aliases();
+
b.tic();
for ( i = 0; i < b.iterations; i++ ) {
- o = help();
- if ( typeof o !== 'object' ) {
- b.fail( 'should return an object' );
+ v = help( values[ i%values.length ] );
+ if ( typeof v !== 'string' && v !== null ) {
+ b.fail( 'should return a string or null' );
}
}
b.toc();
- if ( !isPlainObject( o ) ) {
- b.fail( 'should return a plain object' );
+ if ( !isString( v ) && v !== null ) {
+ b.fail( 'should return a string or null' );
}
b.pass( 'benchmark finished' );
b.end();
diff --git a/lib/node_modules/@stdlib/repl/help/bin/cli b/lib/node_modules/@stdlib/repl/help/bin/cli
new file mode 100755
index 000000000000..be98757c1425
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/help/bin/cli
@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2019 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 resolve = require( 'path' ).resolve;
+var readFileSync = require( '@stdlib/fs/read-file' ).sync;
+var CLI = require( '@stdlib/tools/cli' );
+var help = require( './../lib' );
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var args;
+ var cli;
+ var out;
+
+ // Create a command-line interface:
+ cli = new CLI({
+ 'pkg': require( './../package.json' ),
+ 'options': require( './../etc/cli_opts.json' ),
+ 'help': readFileSync( resolve( __dirname, '..', 'docs', 'usage.txt' ), {
+ 'encoding': 'utf8'
+ })
+ });
+
+ // Get any provided command-line arguments:
+ args = cli.args();
+
+ // Print help text corresponding to a provided alias...
+ out = help( args[ 0 ] );
+ if ( out ) {
+ console.log( out ); // eslint-disable-line no-console
+ } else {
+ cli.exit( 1 );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/repl/help/data/data.csv b/lib/node_modules/@stdlib/repl/help/data/data.csv
new file mode 100644
index 000000000000..c404355e0be8
--- /dev/null
+++ b/lib/node_modules/@stdlib/repl/help/data/data.csv
@@ -0,0 +1,1886 @@
+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"
+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"
+aliases,"\naliases()\n Returns a list of standard library aliases.\n\n Returns\n -------\n out: Array\n List of aliases.\n\n Examples\n --------\n > var o = aliases()\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"
+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.treatmentDf: number\n Treatment degrees of freedom.\n\n out.treatmentSS: number\n Treatment sum of squares.\n\n out.treatmentMSS: number\n Treatment mean sum of squares.\n\n out.errorDf: number\n Error degrees of freedom.\n\n out.errorSS: number\n Error sum of squares.\n\n out.errorMSS: 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"
+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"
+APERY,"\nAPERY\n Apéry's constant.\n\n Examples\n --------\n > APERY\n 1.2020569031595942\n\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"
+ARCH,"\nARCH\n Operating system CPU architecture.\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 - '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 - '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 - '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 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"
+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 not invoke an array's `@@iterator` method, regardless of whether this method\n is defined. To convert an array to an implementation defined iterator,\n invoke 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 not invoke an array's `@@iterator` method, regardless of whether this method\n is defined. To convert an array to an implementation defined iterator,\n invoke 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"
+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 - 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()\n Returns a list of array data types.\n\n The output array contains the following data types:\n\n - float32: single-precision floating-point numbers.\n - float64: double-precision floating-point numbers.\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 Returns\n -------\n out: Array\n List of array data types.\n\n Examples\n --------\n > var out = arrayDataTypes()\n \n\n See Also\n --------\n typedarrayDataTypes, ndarrayDataTypes\n"
+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 real 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"
+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: string (optional)\n Array data type.\n\n dtype2: string (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: string (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, 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: string (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: Array\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"
+arrayview2iterator,"\narrayview2iterator( src[, begin[, end]][, mapFcn[, thisArg]] )\n Returns an iterator which iterates over the elements of an array-like\n 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 not invoke an array's `@@iterator` method, regardless of whether this method\n is defined. To convert an array to an implementation defined iterator,\n invoke 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 not invoke an array's `@@iterator` method, regardless of whether this method\n is defined. To convert an array to an implementation defined iterator,\n invoke 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"
+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"
+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\n"
+base.abs,"\nbase.abs( x )\n Computes the absolute value of `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\n"
+base.abs2,"\nbase.abs2( x )\n Computes the squared absolute value of `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\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.absInt32,"\nbase.absInt32( x )\n Computes an absolute value of a signed 32-bit integer in two's complement\n format.\n\n Parameters\n ----------\n x: integer\n Signed 32-bit integer.\n\n Returns\n -------\n out: integer\n Absolute value.\n\n Examples\n --------\n > var v = base.absInt32( -1|0 )\n 1\n > v = base.absInt32( 2|0 )\n 2\n > v = base.absInt32( 0|0 )\n 0\n\n See Also\n --------\n base.abs\n"
+base.acos,"\nbase.acos( x )\n Compute the arccosine of a 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.acosh,"\nbase.acosh( x )\n Computes the hyperbolic arccosine 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 Hyperbolic arccosine (in radians).\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.acoth,"\nbase.acoth( x )\n Computes the inverse hyperbolic cotangent of a 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 (in radians).\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.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(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 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.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.asin,"\nbase.asin( x )\n Computes the arcsine 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 Arcsine (in radians).\n\n Examples\n --------\n > var y = base.asin( 0.0 )\n 0.0\n > y = base.asin( PI/2.0 )\n ~1.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.asinh,"\nbase.asinh( x )\n Computes the hyperbolic arcsine of a number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Hyperbolic arcsine (in radians).\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 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 Evaluates the arctangent of the quotient of two numbers.\n\n Parameters\n ----------\n y: number\n Numerator.\n\n x: number\n Denominator.\n\n Returns\n -------\n out: number\n Arctangent of `y/x` (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.atanh,"\nbase.atanh( x )\n Computes the hyperbolic arctangent 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 Hyperbolic arctangent (in radians).\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.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.0\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( re, im )\n Computes the absolute value of a complex number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n y: number\n Absolute value.\n\n Examples\n --------\n > var y = base.cabs( 5.0, 3.0 )\n ~5.831\n\n See Also\n --------\n base.cabs2, base.abs\n"
+base.cabs2,"\nbase.cabs2( re, im )\n Computes the squared absolute value of a complex number.\n\n The absolute value of a complex number is its distance from zero.\n\n Parameters\n ----------\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n y: number\n Squared absolute value.\n\n Examples\n --------\n > var y = base.cabs2( 5.0, 3.0 )\n 34.0\n\n See Also\n --------\n base.cabs, base.abs2\n"
+base.cadd,"\nbase.cadd( [out,] re1, im1, re2, im2 )\n Adds two complex numbers.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re1: number\n Real component.\n\n im1: number\n Imaginary component.\n\n re2: number\n Real component.\n\n im2: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var y = base.cadd( 5.0, 3.0, -2.0, 1.0 )\n [ 3.0, 4.0 ]\n\n // Provide an output array:\n > var out = new Float32Array( 2 );\n > y = base.cadd( out, 5.0, 3.0, -2.0, 1.0 )\n [ 3.0, 4.0 ]\n > var bool = ( y === out )\n true\n\n See Also\n --------\n base.cdiv, base.cmul, base.csub\n"
+base.cbrt,"\nbase.cbrt( x )\n Computes the cube root.\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.cceil,"\nbase.cceil( [out,] re, im )\n Rounds a complex number toward positive infinity.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var out = base.cceil( 5.5, 3.3 )\n [ 6.0, 4.0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cceil( out, 5.5, 3.3 )\n [ 6.0, 4.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceiln, base.cfloor, base.cround\n"
+base.cceiln,"\nbase.cceiln( [out,] re, im, n )\n Rounds a complex number to the nearest multiple of `10^n` toward positive\n infinity.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var out = base.cceiln( 5.555, -3.333, -2 )\n [ 5.56, -3.33 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cceiln( out, 5.555, -3.333, -2 )\n [ 5.56, -3.33 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceil, base.cfloorn, base.croundn\n"
+base.ccis,"\nbase.ccis( [out,] re, im )\n Computes the cis function of a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var y = base.ccis( 0.0, 0.0 )\n [ 1.0, 0.0 ]\n\n > var y = base.ccis( 1.0, 0.0 )\n [ ~0.540, ~0.841 ]\n\n > var out = new Float64Array( 2 );\n > var v = base.ccis( out, 1.0, 0.0 )\n [ ~0.540, ~0.841 ]\n > var bool = ( v === out )\n true\n\n"
+base.cdiv,"\nbase.cdiv( [out,] re1, im1, re2, im2 )\n Divides two complex numbers.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re1: number\n Real component.\n\n im1: number\n Imaginary component.\n\n re2: number\n Real component.\n\n im2: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var y = base.cdiv( -13.0, -1.0, -2.0, 1.0 )\n [ 5.0, 3.0 ]\n\n > var out = new Float64Array( 2 );\n > var v = base.cdiv( out, -13.0, -1.0, -2.0, 1.0 )\n [ 5.0, 3.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cadd, base.cmul, base.csub\n"
+base.ceil,"\nbase.ceil( x )\n Rounds a numeric value 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.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 (optional)\n Base. Must be greater than 0. Default: 10.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.ceilsd( 3.14159, 5 )\n 3.1416\n > y = base.ceilsd( 3.14159, 1 )\n 4.0\n > y = base.ceilsd( 12368.0, 2 )\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( [out,] re, im )\n Computes the exponential function of a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var y = base.cexp( 0.0, 0.0 )\n [ 1.0, 0.0 ]\n\n > y = base.cexp( 0.0, 1.0 )\n [ ~0.540, ~0.841 ]\n\n > var out = new Float64Array( 2 );\n > var v = base.cexp( out, 0.0, 1.0 )\n [ ~0.540, ~0.841 ]\n > var bool = ( v === out )\n true\n\n"
+base.cflipsign,"\nbase.cflipsign( [out,] re, im, y )\n Returns a complex number with the same magnitude as `z` and the sign of\n `y*z`.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n y: number\n Number from which to derive the sign.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Function result.\n\n Examples\n --------\n > var out = base.cflipsign( -4.2, 5.5, -9 )\n [ 4.2, -5.5 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cflipsign( out, -4.2, 5.5, 8 )\n [ -4.2, 5.5 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cneg, base.csignum\n"
+base.cfloor,"\nbase.cfloor( [out,] re, im )\n Rounds a complex number toward negative infinity.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Rounded components.\n\n Examples\n --------\n > var out = base.cfloor( 5.5, 3.3 )\n [ 5.0, 3.0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cfloor( out, 5.5, 3.3 )\n [ 5.0, 3.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceil, base.cfloorn, base.cround\n"
+base.cfloorn,"\nbase.cfloorn( [out,] re, im, n )\n Rounds a complex number to the nearest multiple of `10^n` toward negative\n infinity.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var out = base.cfloorn( 5.555, -3.333, -2 )\n [ 5.55, -3.34 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cfloorn( out, 5.555, -3.333, -2 )\n [ 5.55, -3.34 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceiln, base.cfloor, base.croundn\n"
+base.cinv,"\nbase.cinv( [out,] re, im )\n Computes the inverse of a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var y = base.cinv( 2.0, 4.0 )\n [ 0.1, -0.2 ]\n\n > var out = new Float64Array( 2 );\n > var v = base.cinv( out, 2.0, 4.0 )\n [ 0.1, -0.2 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cdiv\n"
+base.clamp,"\nbase.clamp( v, min, max )\n Restricts a value 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.wrap\n"
+base.cmul,"\nbase.cmul( [out,] re1, im1, re2, im2 )\n Multiplies two complex numbers.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re1: number\n Real component.\n\n im1: number\n Imaginary component.\n\n re2: number\n Real component.\n\n im2: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Array containing the real and imaginary components of the result.\n\n Examples\n --------\n > var out = base.cmul( 5.0, 3.0, -2.0, 1.0 )\n [ -13.0, -1.0 ]\n\n // Provide an output array:\n > var out = new Float64Array( 2 );\n > var v = base.cmul( out, 5.0, 3.0, -2.0, 1.0 )\n [ -13.0, -1.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cadd, base.cdiv, base.csub\n"
+base.cneg,"\nbase.cneg( [out,] re, im )\n Negates a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Negated components.\n\n Examples\n --------\n > var out = base.cneg( -4.2, 5.5 )\n [ 4.2, -5.5 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cneg( out, -4.2, 5.5 )\n [ 4.2, -5.5 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cabs\n"
+base.continuedFraction,"\nbase.continuedFraction( generator[, options] )\n Evaluates the continued fraction approximation for the supplied series\n generator using the modified Lentz algorithm.\n\n `generator` can be either a function which returns an array with two\n elements, the `a` and `b` terms of the fraction, or an ES6 Generator object.\n\n By default, the function computes\n\n a1\n ---------------\n b1 + a2\n ----------\n b2 + a3\n -----\n b3 + ...\n\n To evaluate\n\n b0 + a1\n ---------------\n b1 + a2\n ----------\n b2 + a3\n -----\n b3 + ...\n\n set the `keep` option to `true`.\n\n Parameters\n ----------\n generator: Function\n Function returning terms of continued fraction expansion.\n\n options: Object (optional)\n Options.\n\n options.maxIter: integer (optional)\n Maximum number of iterations. Default: `1000000`.\n\n options.tolerance: number (optional)\n Further terms are only added as long as the next term is greater than\n current term times the tolerance. Default: `2.22e-16`.\n\n options.keep: boolean (optional)\n Boolean indicating whether to keep the `b0` term in the continued\n fraction. Default: `false`.\n\n Returns\n -------\n out: number\n Value of continued fraction.\n\n Examples\n --------\n // Continued fraction for (e-1)^(-1):\n > function closure() {\n ... var i = 0;\n ... return function() {\n ... i += 1;\n ... return [ i, i ];\n ... };\n ... };\n > var gen = closure();\n > var out = base.continuedFraction( gen )\n ~0.582\n\n // Using an ES6 generator:\n > function* generator() {\n ... var i = 0;\n ... while ( true ) {\n ... i += 1;\n ... yield [ i, i ];\n ... }\n ... };\n > gen = generator();\n > out = base.continuedFraction( gen )\n ~0.582\n\n // Set options:\n > out = base.continuedFraction( generator(), { 'keep': true } )\n ~1.718\n > out = base.continuedFraction( generator(), { 'maxIter': 10 } )\n ~0.582\n > out = base.continuedFraction( generator(), { 'tolerance': 1e-1 } )\n ~0.579\n\n"
+base.copysign,"\nbase.copysign( x, y )\n Returns a double-precision floating-point number with the magnitude of `x`\n and the sign of `y`.\n\n Parameters\n ----------\n x: number\n Number from which to derive a magnitude.\n\n y: number\n Number from which to derive a sign.\n\n Returns\n -------\n z: number\n Double-precision floating-point number.\n\n Examples\n --------\n > var z = base.copysign( -3.14, 10.0 )\n 3.14\n > z = base.copysign( 3.14, -1.0 )\n -3.14\n > z = base.copysign( 1.0, -0.0 )\n -1.0\n > z = base.copysign( -3.14, -0.0 )\n -3.14\n > z = base.copysign( -0.0, 1.0 )\n 0.0\n\n See Also\n --------\n base.flipsign\n"
+base.cos,"\nbase.cos( x )\n Computes the cosine of a number.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Cosine.\n\n Examples\n --------\n > var y = base.cos( 0.0 )\n 1.0\n > y = base.cos( PI/4.0 )\n ~0.707\n > y = base.cos( -PI/6.0 )\n ~0.866\n > y = base.cos( NaN )\n NaN\n\n See Also\n --------\n base.cospi, base.cosm1, base.sin, base.tan\n"
+base.cosh,"\nbase.cosh( x )\n Computes the hyperbolic cosine of a number.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Hyperbolic cosine.\n\n Examples\n --------\n > var y = base.cosh( 0.0 )\n 1.0\n > y = base.cosh( 2.0 )\n ~3.762\n > y = base.cosh( -2.0 )\n ~3.762\n > y = base.cosh( NaN )\n NaN\n\n See Also\n --------\n base.cos, base.sinh, base.tanh\n"
+base.cosm1,"\nbase.cosm1( x )\n Computes the cosine of a number minus one.\n\n This function should be used instead of manually calculating `cos(x)-1` when\n `x` is near unity.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Cosine minus one.\n\n Examples\n --------\n > var y = base.cosm1( 0.0 )\n 0.0\n > y = base.cosm1( PI/4.0 )\n ~-0.293\n > y = base.cosm1( -PI/6.0 )\n ~-0.134\n > y = base.cosm1( NaN )\n NaN\n\n See Also\n --------\n base.cos\n"
+base.cospi,"\nbase.cospi( x )\n Computes the value of `cos(πx)`.\n\n This function computes `cos(πx)` more accurately than the obvious approach,\n especially for large `x`.\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.cospi( 0.0 )\n 1.0\n > y = base.cospi( 0.5 )\n 0.0\n > y = base.cospi( 0.1 )\n ~0.951\n > y = base.cospi( NaN )\n NaN\n\n See Also\n --------\n base.cos\n"
+base.covercos,"\nbase.covercos( x )\n Computes the coversed cosine.\n\n The coversed cosine is defined as `1 + sin(x)`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Coversed cosine.\n\n Examples\n --------\n > var y = base.covercos( 3.14 )\n ~1.0016\n > y = base.covercos( -4.2 )\n ~1.8716\n > y = base.covercos( -4.6 )\n ~1.9937\n > y = base.covercos( 9.5 )\n ~0.9248\n > y = base.covercos( -0.0 )\n 1.0\n\n See Also\n --------\n base.coversin, base.vercos\n"
+base.coversin,"\nbase.coversin( x )\n Computes the coversed sine.\n\n The coversed sine is defined as `1 - sin(x)`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Coversed sine.\n\n Examples\n --------\n > var y = base.coversin( 3.14 )\n ~0.9984\n > y = base.coversin( -4.2 )\n ~0.1284\n > y = base.coversin( -4.6 )\n ~0.0063\n > y = base.coversin( 9.5 )\n ~1.0752\n > y = base.coversin( -0.0 )\n 1.0\n\n See Also\n --------\n base.covercos, base.versin\n"
+base.cphase,"\nbase.cphase( re, im )\n Computes the argument of a complex number in radians.\n\n The argument of a complex number, also known as the phase, is the angle of\n the radius extending from the origin to the complex number plotted in the\n complex plane and the positive real axis.\n\n Parameters\n ----------\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n phi: number\n Argument.\n\n Examples\n --------\n > var phi = base.cphase( 5.0, 3.0 )\n ~0.5404\n\n See Also\n --------\n base.cabs\n"
+base.cpolar,"\nbase.cpolar( [out,] re, im )\n Returns the absolute value and phase of a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Absolute value and phase, respectively.\n\n Examples\n --------\n > var out = base.cpolar( 5.0, 3.0 )\n [ ~5.83, ~0.5404 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cpolar( out, 5.0, 3.0 )\n [ ~5.83, ~0.5404 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cabs, base.cphase\n"
+base.cround,"\nbase.cround( [out,] re, im )\n Rounds a complex number to the nearest integer.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Rounded components.\n\n Examples\n --------\n > var out = base.cround( 5.5, 3.3 )\n [ 6.0, 3.0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.cround( out, 5.5, 3.3 )\n [ 6.0, 3.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceil, base.cfloor, base.croundn\n"
+base.croundn,"\nbase.croundn( [out,] re, im, n )\n Rounds a complex number to the nearest multiple of `10^n`.\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 out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n n: integer\n Integer power of 10.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Real and imaginary components.\n\n Examples\n --------\n > var out = base.croundn( 5.555, -3.336, -2 )\n [ 5.56, -3.34 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.croundn( out, 5.555, -3.336, -2 )\n [ 5.56, -3.34 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cceiln, base.cfloorn, base.cround\n"
+base.csignum,"\nbase.csignum( [out,] re, im )\n Evaluates the signum function of a complex number.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re: number\n Real component.\n\n im: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Function result.\n\n Examples\n --------\n > var out = base.csignum( -4.2, 5.5 )\n [ -0.6069136033622302, 0.79476781392673 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.csignum( out, -4.2, 5.5 )\n [ -0.6069136033622302, 0.79476781392673 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.signum\n"
+base.csub,"\nbase.csub( [out,] re1, im1, re2, im2 )\n Subtracts two complex numbers.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n re1: number\n Real component.\n\n im1: number\n Imaginary component.\n\n re2: number\n Real component.\n\n im2: number\n Imaginary component.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Array containing the real and imaginary components of the result.\n\n Examples\n --------\n > var out = base.csub( 5.0, 3.0, -2.0, 1.0 )\n [ 7.0, 2.0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.csub( out, 5.0, 3.0, -2.0, 1.0 )\n [ 7.0, 2.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.cadd, base.cdiv, base.cmul\n"
+base.dasum,"\nbase.dasum( N, x, stride )\n Computes the sum of the absolute values.\n\n The sum of absolute values corresponds to the *L1* norm.\n\n The `N` and `stride` parameters determine which elements in `x` are used to\n compute the sum.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n If `N` or `stride` is less than or equal to `0`, the function returns `0`.\n\n Parameters\n ----------\n N: integer\n Number of elements to sum.\n\n x: Float64Array\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n sum: number\n Sum of absolute values.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\n > var sum = base.dasum( x.length, x, 1 )\n 19.0\n\n // Sum every other value:\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > sum = base.dasum( N, x, stride )\n 10.0\n\n // Use view offset; e.g., starting at 2nd element:\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 > N = base.floor( x0.length / 2 );\n > sum = base.dasum( N, x1, stride )\n 12.0\n\n\nbase.dasum.ndarray( N, x, stride, offset )\n Computes the sum of absolute values 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 elements to sum.\n\n x: Float64Array\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n sum: number\n Sum of absolute values.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );\n > var sum = base.dasum.ndarray( x.length, x, 1, 0 )\n 19.0\n\n // Sum the last three elements:\n > x = new Float64Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );\n > sum = base.dasum.ndarray( 3, x, -1, x.length-1 )\n 15.0\n\n\nbase.dasum.wasm( [options] )\n Returns a memory managed function to compute the sum of absolute values.\n\n For an externally defined `Float64Array`, data must be copied to the heap.\n\n Parameters\n ----------\n options: Object (optional)\n Options.\n\n options.memory: integer (optional)\n Total memory. If not provided a buffer, setting the memory option\n instructs the returned function to allocate an internal memory store of\n the specified size.\n\n options.stack: integer (optional)\n Total stack size. Must be less than the memory option and large enough\n for a program's needs. Default: `1024` bytes.\n\n options.buffer: ArrayBuffer (optional)\n `ArrayBuffer` serving as the underlying memory store. If not provided,\n each returned function will allocate and manage its own memory. If\n provided a memory option, the buffer `byteLength` must equal the\n specified total memory.\n\n Returns\n -------\n out: Function\n Memory managed function.\n\n Examples\n --------\n > var wasm = base.dasum.wasm();\n > var N = 5;\n\n // Allocate space on the heap:\n > var bytes = wasm.malloc( N * 8 );\n\n // Create a Float64Array view:\n > var view = new Float64Array( bytes.buffer, bytes.byteOffset, N );\n\n // Copy data to the heap:\n > view.set( [ 1.0, -2.0, 3.0, -4.0, 5.0 ] );\n\n // Compute the sum of absolute values (passing in the heap buffer):\n > var s = wasm( N, bytes, 1 )\n 15.0\n\n // Free the memory:\n > wasm.free( bytes );\n\n See Also\n --------\n base.daxpy, base.dcopy\n"
+base.daxpy,"\nbase.daxpy( N, alpha, x, strideX, y, strideY )\n Multiplies `x` by a constant `alpha` and adds the result to `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 If `N <= 0` or `alpha == 0`, the function returns `y` unchanged.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n alpha: number\n Constant.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n y: Float64Array\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n Returns\n -------\n y: Float64Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n > var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n > var alpha = 5.0;\n > base.daxpy( x.length, alpha, x, 1, y, 1 )\n [ 6.0, 11.0, 16.0, 21.0, 26.0 ]\n\n // Using `N` and `stride` parameters:\n > var N = base.floor( x.length / 2 );\n > y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n > base.daxpy( N, alpha, x, 2, y, -1 )\n [ 26.0, 16.0, 6.0, 1.0, 1.0, 1.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 y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\n > N = base.floor( x0.length / 2 );\n > base.daxpy( N, 5.0, x1, -2, y1, 1 )\n [ 40.0, 33.0, 22.0 ]\n > y0\n [ 7.0, 8.0, 9.0, 40.0, 31.0, 22.0 ]\n\n\nbase.daxpy.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY )\n Multiplies `x` by a constant `alpha` and adds the result to `y`, with\n 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 alpha: number\n Constant.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Float64Array\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: Float64Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n > var y = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n > var alpha = 5.0;\n > base.daxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 )\n [ 6.0, 11.0, 16.0, 21.0, 26.0 ]\n\n // Advanced indexing:\n > x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > y = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.daxpy.ndarray( N, alpha, x, 2, 1, y, -1, y.length-1 )\n [ 7.0, 8.0, 9.0, 40.0, 31.0, 22.0 ]\n\n\nbase.daxpy.wasm( [options] )\n Returns a memory managed function to multiply `x` by a constant `alpha` and\n add the result to `y`.\n\n For externally defined `Float64Arrays`, data must be copied to the heap.\n\n Parameters\n ----------\n options: Object (optional)\n Options.\n\n options.memory: integer (optional)\n Total memory. If not provided a buffer, setting the memory option\n instructs the returned function to allocate an internal memory store of\n the specified size.\n\n options.stack: integer (optional)\n Total stack size. Must be less than the memory option and large enough\n for a program's needs. Default: `1024` bytes.\n\n options.buffer: ArrayBuffer (optional)\n `ArrayBuffer` serving as the underlying memory store. If not provided,\n each returned function will allocate and manage its own memory. If\n provided a memory option, the buffer `byteLength` must equal the\n specified total memory.\n\n Returns\n -------\n out: Function\n Memory managed function.\n\n Examples\n --------\n > var wasm = base.daxpy.wasm();\n > var N = 5;\n\n // Allocate space on the heap:\n > var xbytes = wasm.malloc( N * 8 );\n > var ybytes = wasm.malloc( N * 8 );\n\n // Create Float64Array views:\n > var x = new Float64Array( xbytes.buffer, xbytes.byteOffset, N );\n > var y = new Float64Array( ybytes.buffer, ybytes.byteOffset, N );\n\n // Copy data to the heap:\n > x.set( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n > y.set( [ 1.0, 1.0, 1.0, 1.0, 1.0 ] );\n\n // Multiply and add alpha:\n > var alpha = 5.0;\n > wasm( x.length, alpha, xbytes, 1, ybytes, 1 );\n > y\n [ 6.0, 11.0, 16.0, 21.0, 26.0 ]\n\n // Free the memory:\n > wasm.free( xbytes );\n > wasm.free( ybytes );\n\n See Also\n --------\n base.dasum, base.dcopy\n"
+base.dcopy,"\nbase.dcopy( N, x, strideX, y, strideY )\n Copies values from `x` into `y`.\n\n The `N` and `stride` parameters determine how values from `x` are copied\n into `y`.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n If `N` is less than or equal to `0`, the function returns `y` unchanged.\n\n Parameters\n ----------\n N: integer\n Number of values to copy.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n y: Float64Array\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n Returns\n -------\n y: Float64Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n > var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\n > base.dcopy( x.length, x, 1, y, 1 )\n [ 1.0, 2.0, 3.0, 4.0, 5.0 ]\n\n // Advanced indexing:\n > x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > y = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.dcopy( N, x, -2, y, 1 )\n [ 5.0, 3.0, 1.0, 10.0, 11.0, 12.0 ]\n\n // Using typed array views:\n > var x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > var y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\n > N = base.floor( x0.length / 2 );\n > base.dcopy( N, x1, -2, y1, 1 )\n [ 6.0, 4.0, 2.0 ]\n > y0\n [ 7.0, 8.0, 9.0, 6.0, 4.0, 2.0 ]\n\n\nbase.dcopy.ndarray( N, x, strideX, offsetX, y, strideY, offsetY )\n Copies values from `x` into `y`, with alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameters support indexing semantics based on starting\n indices.\n\n Parameters\n ----------\n N: integer\n Number of values to copy.\n\n x: Float64Array\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Float64Array\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: Float64Array\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );\n > var y = new Float64Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );\n > base.dcopy.ndarray( x.length, x, 1, 0, y, 1, 0 )\n [ 1.0, 2.0, 3.0, 4.0, 5.0 ]\n\n // Advanced indexing:\n > x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > y = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var N = base.floor( x.length / 2 );\n > base.dcopy.ndarray( N, x, 2, 1, y, -1, y.length-1 )\n [ 7.0, 8.0, 9.0, 6.0, 4.0, 2.0 ]\n\n See Also\n --------\n base.dasum, base.daxpy\n"
+base.deg2rad,"\nbase.deg2rad( x )\n Converts an angle from degrees to radians.\n\n Parameters\n ----------\n x: number\n Angle in degrees.\n\n Returns\n -------\n r: number\n Angle in radians.\n\n Examples\n --------\n > var r = base.deg2rad( 90.0 )\n ~1.571\n > r = base.deg2rad( -45.0 )\n ~-0.785\n > r = base.deg2rad( NaN )\n NaN\n\n See Also\n --------\n base.rad2deg\n"
+base.digamma,"\nbase.digamma( x )\n Evaluates the digamma function.\n\n If `x` is zero or a negative integer, the function returns `NaN`.\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 value.\n\n Examples\n --------\n > var y = base.digamma( -2.5 )\n ~1.103\n > y = base.digamma( 1.0 )\n ~-0.577\n > y = base.digamma( 10.0 )\n ~2.252\n > y = base.digamma( NaN )\n NaN\n > y = base.digamma( -1.0 )\n NaN\n\n See Also\n --------\n base.trigamma, base.gamma\n"
+base.diracDelta,"\nbase.diracDelta( x )\n Evaluates the Dirac delta function.\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.diracDelta( 3.14 )\n 0.0\n > y = base.diracDelta( 0.0 )\n Infinity\n\n See Also\n --------\n base.kroneckerDelta\n"
+base.dists.arcsine.Arcsine,"\nbase.dists.arcsine.Arcsine( [a, b] )\n Returns an arcsine distribution object.\n\n Parameters\n ----------\n a: number (optional)\n Minimum support. Must be less than `b`. Default: `0.0`.\n\n b: number (optional)\n Maximum support. Must be greater than `a`. Default: `1.0`.\n\n Returns\n -------\n arcsine: Object\n Distribution instance.\n\n arcsine.a: number\n Minimum support. If set, the value must be less than `b`.\n\n arcsine.b: number\n Maximum support. If set, the value must be greater than `a`.\n\n arcsine.entropy: number\n Read-only property which returns the differential entropy.\n\n arcsine.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n arcsine.mean: number\n Read-only property which returns the expected value.\n\n arcsine.median: number\n Read-only property which returns the median.\n\n arcsine.mode: number\n Read-only property which returns the mode.\n\n arcsine.skewness: number\n Read-only property which returns the skewness.\n\n arcsine.stdev: number\n Read-only property which returns the standard deviation.\n\n arcsine.variance: number\n Read-only property which returns the variance.\n\n arcsine.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n arcsine.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n arcsine.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n arcsine.pdf: Function\n Evaluates the probability density function (PDF).\n\n arcsine.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var arcsine = base.dists.arcsine.Arcsine( 0.0, 1.0 );\n > arcsine.a\n 0.0\n > arcsine.b\n 1.0\n > arcsine.entropy\n ~-0.242\n > arcsine.kurtosis\n -1.5\n > arcsine.mean\n 0.5\n > arcsine.median\n 0.5\n > arcsine.mode\n 0.0\n > arcsine.skewness\n 0.0\n > arcsine.stdev\n ~0.354\n > arcsine.variance\n 0.125\n > arcsine.cdf( 0.8 )\n ~0.705\n > arcsine.logcdf( 0.8 )\n ~-0.35\n > arcsine.logpdf( 0.4 )\n ~-0.431\n > arcsine.pdf( 0.8 )\n ~0.796\n > arcsine.quantile( 0.8 )\n ~0.905\n\n"
+base.dists.arcsine.cdf,"\nbase.dists.arcsine.cdf( x, a, b )\n Evaluates the cumulative distribution function (CDF) for an arcsine\n distribution with minimum support `a` and maximum support `b` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.arcsine.cdf( 9.0, 0.0, 10.0 )\n ~0.795\n > y = base.dists.arcsine.cdf( 0.5, 0.0, 2.0 )\n ~0.333\n > y = base.dists.arcsine.cdf( PINF, 2.0, 4.0 )\n 1.0\n > y = base.dists.arcsine.cdf( NINF, 2.0, 4.0 )\n 0.0\n > y = base.dists.arcsine.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.arcsine.cdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.arcsine.cdf( 2.0, 1.0, 0.0 )\n NaN\n\n\nbase.dists.arcsine.cdf.factory( a, b )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of an arcsine distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.arcsine.cdf.factory( 0.0, 10.0 );\n > var y = mycdf( 0.5 )\n ~0.144\n > y = mycdf( 8.0 )\n ~0.705\n\n"
+base.dists.arcsine.entropy,"\nbase.dists.arcsine.entropy( a, b )\n Returns the differential entropy of an arcsine distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.arcsine.entropy( 0.0, 1.0 )\n ~-0.242\n > v = base.dists.arcsine.entropy( 4.0, 12.0 )\n ~1.838\n > v = base.dists.arcsine.entropy( 2.0, 8.0 )\n ~1.55\n\n"
+base.dists.arcsine.kurtosis,"\nbase.dists.arcsine.kurtosis( a, b )\n Returns the excess kurtosis of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.arcsine.kurtosis( 0.0, 1.0 )\n -1.5\n > v = base.dists.arcsine.kurtosis( 4.0, 12.0 )\n -1.5\n > v = base.dists.arcsine.kurtosis( 2.0, 8.0 )\n -1.5\n\n"
+base.dists.arcsine.logcdf,"\nbase.dists.arcsine.logcdf( x, a, b )\n Evaluates the logarithm of the cumulative distribution function (CDF) for an\n arcsine distribution with minimum support `a` and maximum support `b` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.arcsine.logcdf( 9.0, 0.0, 10.0 )\n ~-0.229\n > y = base.dists.arcsine.logcdf( 0.5, 0.0, 2.0 )\n ~-1.1\n > y = base.dists.arcsine.logcdf( PINF, 2.0, 4.0 )\n 0.0\n > y = base.dists.arcsine.logcdf( NINF, 2.0, 4.0 )\n -Infinity\n > y = base.dists.arcsine.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.arcsine.logcdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.arcsine.logcdf( 2.0, 1.0, 0.0 )\n NaN\n\n\nbase.dists.arcsine.logcdf.factory( a, b )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of an arcsine distribution with minimum support\n `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.arcsine.logcdf.factory( 0.0, 10.0 );\n > var y = mylogcdf( 0.5 )\n ~-1.941\n > y = mylogcdf( 8.0 )\n ~-0.35\n\n"
+base.dists.arcsine.logpdf,"\nbase.dists.arcsine.logpdf( x, a, b )\n Evaluates the logarithm of the probability density function (PDF) for an\n arcsine distribution with minimum support `a` and maximum support `b` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.arcsine.logpdf( 2.0, 0.0, 4.0 )\n ~-1.838\n > y = base.dists.arcsine.logpdf( 5.0, 0.0, 4.0 )\n -Infinity\n > y = base.dists.arcsine.logpdf( 0.25, 0.0, 1.0 )\n ~-0.308\n > y = base.dists.arcsine.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.arcsine.logpdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.arcsine.logpdf( 2.0, 3.0, 1.0 )\n NaN\n\n\nbase.dists.arcsine.logpdf.factory( a, b )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of an arcsine distribution with minimum support `a` and\n maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.arcsine.logpdf.factory( 6.0, 7.0 );\n > var y = mylogPDF( 7.0 )\n Infinity\n > y = mylogPDF( 5.0 )\n -Infinity\n\n"
+base.dists.arcsine.mean,"\nbase.dists.arcsine.mean( a, b )\n Returns the expected value of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.arcsine.mean( 0.0, 1.0 )\n 0.5\n > v = base.dists.arcsine.mean( 4.0, 12.0 )\n 8.0\n > v = base.dists.arcsine.mean( 2.0, 8.0 )\n 5.0\n\n"
+base.dists.arcsine.median,"\nbase.dists.arcsine.median( a, b )\n Returns the median of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.arcsine.median( 0.0, 1.0 )\n 0.5\n > v = base.dists.arcsine.median( 4.0, 12.0 )\n 8.0\n > v = base.dists.arcsine.median( 2.0, 8.0 )\n 5.0\n\n"
+base.dists.arcsine.mode,"\nbase.dists.arcsine.mode( a, b )\n Returns the mode of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.arcsine.mode( 0.0, 1.0 )\n 0.0\n > v = base.dists.arcsine.mode( 4.0, 12.0 )\n 4.0\n > v = base.dists.arcsine.mode( 2.0, 8.0 )\n 2.0\n\n"
+base.dists.arcsine.pdf,"\nbase.dists.arcsine.pdf( x, a, b )\n Evaluates the probability density function (PDF) for an arcsine distribution\n with minimum support `a` and maximum support `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.arcsine.pdf( 2.0, 0.0, 4.0 )\n ~0.159\n > y = base.dists.arcsine.pdf( 5.0, 0.0, 4.0 )\n 0.0\n > y = base.dists.arcsine.pdf( 0.25, 0.0, 1.0 )\n ~0.735\n > y = base.dists.arcsine.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.arcsine.pdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.arcsine.pdf( 2.0, 3.0, 1.0 )\n NaN\n\n\nbase.dists.arcsine.pdf.factory( a, b )\n Returns a function for evaluating the probability density function (PDF) of\n an arcsine distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.arcsine.pdf.factory( 6.0, 7.0 );\n > var y = myPDF( 7.0 )\n Infinity\n > y = myPDF( 5.0 )\n 0.0\n\n"
+base.dists.arcsine.quantile,"\nbase.dists.arcsine.quantile( p, a, b )\n Evaluates the quantile function for an arcsine distribution with minimum\n support `a` and maximum support `b` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.arcsine.quantile( 0.8, 0.0, 1.0 )\n ~0.905\n > y = base.dists.arcsine.quantile( 0.5, 0.0, 10.0 )\n ~5.0\n\n > y = base.dists.arcsine.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.arcsine.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.arcsine.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.arcsine.quantile( 0.0, 0.0, NaN )\n NaN\n\n > y = base.dists.arcsine.quantile( 0.5, 2.0, 1.0 )\n NaN\n\n\nbase.dists.arcsine.quantile.factory( a, b )\n Returns a function for evaluating the quantile function of an arcsine\n distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.arcsine.quantile.factory( 0.0, 4.0 );\n > var y = myQuantile( 0.8 )\n ~3.618\n\n"
+base.dists.arcsine.skewness,"\nbase.dists.arcsine.skewness( a, b )\n Returns the skewness of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.arcsine.skewness( 0.0, 1.0 )\n 0.0\n > v = base.dists.arcsine.skewness( 4.0, 12.0 )\n 0.0\n > v = base.dists.arcsine.skewness( 2.0, 8.0 )\n 0.0\n\n"
+base.dists.arcsine.stdev,"\nbase.dists.arcsine.stdev( a, b )\n Returns the standard deviation of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.arcsine.stdev( 0.0, 1.0 )\n ~0.354\n > v = base.dists.arcsine.stdev( 4.0, 12.0 )\n ~2.828\n > v = base.dists.arcsine.stdev( 2.0, 8.0 )\n ~2.121\n\n"
+base.dists.arcsine.variance,"\nbase.dists.arcsine.variance( a, b )\n Returns the variance of an arcsine distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.arcsine.variance( 0.0, 1.0 )\n ~0.125\n > v = base.dists.arcsine.variance( 4.0, 12.0 )\n 8.0\n > v = base.dists.arcsine.variance( 2.0, 8.0 )\n ~4.5\n\n"
+base.dists.bernoulli.Bernoulli,"\nbase.dists.bernoulli.Bernoulli( [p] )\n Returns a Bernoulli distribution object.\n\n Parameters\n ----------\n p: number (optional)\n Success probability. Must be between `0` and `1`. Default: `0.5`.\n\n Returns\n -------\n bernoulli: Object\n Distribution instance.\n\n bernoulli.p: number\n Success probability. If set, the value must be between `0` and `1`.\n\n bernoulli.entropy: number\n Read-only property which returns the differential entropy.\n\n bernoulli.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n bernoulli.mean: number\n Read-only property which returns the expected value.\n\n bernoulli.median: number\n Read-only property which returns the median.\n\n bernoulli.skewness: number\n Read-only property which returns the skewness.\n\n bernoulli.stdev: number\n Read-only property which returns the standard deviation.\n\n bernoulli.variance: number\n Read-only property which returns the variance.\n\n bernoulli.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n bernoulli.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n bernoulli.pmf: Function\n Evaluates the probability mass function (PMF).\n\n bernoulli.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var bernoulli = base.dists.bernoulli.Bernoulli( 0.6 );\n > bernoulli.p\n 0.6\n > bernoulli.entropy\n ~0.673\n > bernoulli.kurtosis\n ~-1.833\n > bernoulli.mean\n 0.6\n > bernoulli.median\n 1.0\n > bernoulli.skewness\n ~-0.408\n > bernoulli.stdev\n ~0.49\n > bernoulli.variance\n ~0.24\n > bernoulli.cdf( 0.5 )\n 0.4\n > bernoulli.mgf( 3.0 )\n ~12.451\n > bernoulli.pmf( 0.0 )\n 0.4\n > bernoulli.quantile( 0.7 )\n 1.0\n\n"
+base.dists.bernoulli.cdf,"\nbase.dists.bernoulli.cdf( x, p )\n Evaluates the cumulative distribution function (CDF) for a Bernoulli\n distribution with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.bernoulli.cdf( 0.5, 0.5 )\n 0.5\n > y = base.dists.bernoulli.cdf( 0.8, 0.1 )\n 0.9\n > y = base.dists.bernoulli.cdf( -1.0, 0.4 )\n 0.0\n > y = base.dists.bernoulli.cdf( 1.5, 0.4 )\n 1.0\n > y = base.dists.bernoulli.cdf( NaN, 0.5 )\n NaN\n > y = base.dists.bernoulli.cdf( 0.0, NaN )\n NaN\n // Invalid probability:\n > y = base.dists.bernoulli.cdf( 2.0, 1.4 )\n NaN\n\n\nbase.dists.bernoulli.cdf.factory( p )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Bernoulli distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.bernoulli.cdf.factory( 0.5 );\n > var y = mycdf( 3.0 )\n 1.0\n > y = mycdf( 0.7 )\n 0.5\n\n"
+base.dists.bernoulli.entropy,"\nbase.dists.bernoulli.entropy( p )\n Returns the entropy of a Bernoulli distribution with success probability\n `p` (in nats).\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.bernoulli.entropy( 0.1 )\n ~0.325\n > v = base.dists.bernoulli.entropy( 0.5 )\n ~0.693\n\n"
+base.dists.bernoulli.kurtosis,"\nbase.dists.bernoulli.kurtosis( p )\n Returns the excess kurtosis of a Bernoulli distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.bernoulli.kurtosis( 0.1 )\n ~5.111\n > v = base.dists.bernoulli.kurtosis( 0.5 )\n -2.0\n\n"
+base.dists.bernoulli.mean,"\nbase.dists.bernoulli.mean( p )\n Returns the expected value of a Bernoulli distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.bernoulli.mean( 0.1 )\n 0.1\n > v = base.dists.bernoulli.mean( 0.5 )\n 0.5\n\n"
+base.dists.bernoulli.median,"\nbase.dists.bernoulli.median( p )\n Returns the median of a Bernoulli distribution with success probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: integer\n Median.\n\n Examples\n --------\n > var v = base.dists.bernoulli.median( 0.1 )\n 0\n > v = base.dists.bernoulli.median( 0.8 )\n 1\n\n"
+base.dists.bernoulli.mgf,"\nbase.dists.bernoulli.mgf( t, p )\n Evaluates the moment-generating function (MGF) for a Bernoulli\n distribution with success probability `p` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.bernoulli.mgf( 0.2, 0.5 )\n ~1.111\n > y = base.dists.bernoulli.mgf( 0.4, 0.5 )\n ~1.246\n > y = base.dists.bernoulli.mgf( NaN, 0.0 )\n NaN\n > y = base.dists.bernoulli.mgf( 0.0, NaN )\n NaN\n > y = base.dists.bernoulli.mgf( -2.0, -1.0 )\n NaN\n > y = base.dists.bernoulli.mgf( 0.2, 2.0 )\n NaN\n\n\nbase.dists.bernoulli.mgf.factory( p )\n Returns a function for evaluating the moment-generating function (MGF) of a\n Bernoulli distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.bernoulli.mgf.factory( 0.8 );\n > var y = mymgf( -0.2 )\n ~0.855\n\n"
+base.dists.bernoulli.mode,"\nbase.dists.bernoulli.mode( p )\n Returns the mode of a Bernoulli distribution with success probability `p`.\n\n For `p = 0.5`, the mode is either `0` or `1`. This implementation returns\n `0` for `p = 0.5`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: integer\n Mode.\n\n Examples\n --------\n > var v = base.dists.bernoulli.mode( 0.1 )\n 0\n > v = base.dists.bernoulli.mode( 0.8 )\n 1\n\n"
+base.dists.bernoulli.pmf,"\nbase.dists.bernoulli.pmf( x, p )\n Evaluates the probability mass function (PMF) for a Bernoulli distribution\n with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.bernoulli.pmf( 1.0, 0.3 )\n 0.3\n > y = base.dists.bernoulli.pmf( 0.0, 0.7 )\n 0.3\n > y = base.dists.bernoulli.pmf( -1.0, 0.5 )\n 0.0\n > y = base.dists.bernoulli.pmf( 0.0, NaN )\n NaN\n > y = base.dists.bernoulli.pmf( NaN, 0.5 )\n NaN\n // Invalid success probability:\n > y = base.dists.bernoulli.pmf( 0.0, 1.5 )\n NaN\n\n\nbase.dists.bernoulli.pmf.factory( p )\n Returns a function for evaluating the probability mass function (PMF) of a\n Bernoulli distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var mypmf = base.dists.bernoulli.pmf.factory( 0.5 );\n > var y = mypmf( 1.0 )\n 0.5\n > y = mypmf( 0.0 )\n 0.5\n\n"
+base.dists.bernoulli.quantile,"\nbase.dists.bernoulli.quantile( r, p )\n Evaluates the quantile function for a Bernoulli distribution with success\n probability `p` at a probability `r`.\n\n If `r < 0` or `r > 1`, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n r: number\n Input probability.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.bernoulli.quantile( 0.8, 0.4 )\n 1\n > y = base.dists.bernoulli.quantile( 0.5, 0.4 )\n 0\n > y = base.dists.bernoulli.quantile( 0.9, 0.1 )\n 0\n\n > y = base.dists.bernoulli.quantile( -0.2, 0.1 )\n NaN\n\n > y = base.dists.bernoulli.quantile( NaN, 0.8 )\n NaN\n > y = base.dists.bernoulli.quantile( 0.4, NaN )\n NaN\n\n > y = base.dists.bernoulli.quantile( 0.5, -1.0 )\n NaN\n > y = base.dists.bernoulli.quantile( 0.5, 1.5 )\n NaN\n\n\nbase.dists.bernoulli.quantile.factory( p )\n Returns a function for evaluating the quantile function of a Bernoulli\n distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.bernoulli.quantile.factory( 0.4 );\n > var y = myquantile( 0.4 )\n 0\n > y = myquantile( 0.8 )\n 1\n > y = myquantile( 1.0 )\n 1\n\n"
+base.dists.bernoulli.skewness,"\nbase.dists.bernoulli.skewness( p )\n Returns the skewness of a Bernoulli distribution with success probability\n `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.bernoulli.skewness( 0.1 )\n ~2.667\n > v = base.dists.bernoulli.skewness( 0.5 )\n 0.0\n\n"
+base.dists.bernoulli.stdev,"\nbase.dists.bernoulli.stdev( p )\n Returns the standard deviation of a Bernoulli distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.bernoulli.stdev( 0.1 )\n ~0.3\n > v = base.dists.bernoulli.stdev( 0.5 )\n 0.5\n\n"
+base.dists.bernoulli.variance,"\nbase.dists.bernoulli.variance( p )\n Returns the variance of a Bernoulli distribution with success probability\n `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.bernoulli.variance( 0.1 )\n ~0.09\n > v = base.dists.bernoulli.variance( 0.5 )\n 0.25\n\n"
+base.dists.beta.Beta,"\nbase.dists.beta.Beta( [α, β] )\n Returns a beta distribution object.\n\n Parameters\n ----------\n α: number (optional)\n First shape parameter. Must be greater than `0`. Default: `1.0`.\n\n β: number (optional)\n Second shape parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n beta: Object\n Distribution instance.\n\n beta.alpha: number\n First shape parameter. If set, the value must be greater than `0`.\n\n beta.beta: number\n Second shape parameter. If set, the value must be greater than `0`.\n\n beta.entropy: number\n Read-only property which returns the differential entropy.\n\n beta.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n beta.mean: number\n Read-only property which returns the expected value.\n\n beta.median: number\n Read-only property which returns the median.\n\n beta.mode: number\n Read-only property which returns the mode.\n\n beta.skewness: number\n Read-only property which returns the skewness.\n\n beta.stdev: number\n Read-only property which returns the standard deviation.\n\n beta.variance: number\n Read-only property which returns the variance.\n\n beta.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n beta.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n beta.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n beta.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n beta.pdf: Function\n Evaluates the probability density function (PDF).\n\n beta.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var beta = base.dists.beta.Beta( 1.0, 1.0 );\n > beta.alpha\n 1.0\n > beta.beta\n 1.0\n > beta.entropy\n 0.0\n > beta.kurtosis\n -1.2\n > beta.mean\n 0.5\n > beta.median\n 0.5\n > beta.mode\n NaN\n > beta.skewness\n 0.0\n > beta.stdev\n ~0.289\n > beta.variance\n ~0.0833\n > beta.cdf( 0.8 )\n 0.8\n > beta.logcdf( 0.8 )\n ~-0.223\n > beta.logpdf( 1.0 )\n 0.0\n > beta.mgf( 3.14 )\n ~7.0394\n > beta.pdf( 1.0 )\n 1.0\n > beta.quantile( 0.8 )\n 0.8\n\n"
+base.dists.beta.cdf,"\nbase.dists.beta.cdf( x, α, β )\n Evaluates the cumulative distribution function (CDF) for a beta distribution\n with first shape parameter `α` and second shape parameter `β` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.beta.cdf( 0.5, 1.0, 1.0 )\n 0.5\n > y = base.dists.beta.cdf( 0.5, 2.0, 4.0 )\n ~0.813\n > y = base.dists.beta.cdf( 0.2, 2.0, 2.0 )\n ~0.104\n > y = base.dists.beta.cdf( 0.8, 4.0, 4.0 )\n ~0.967\n > y = base.dists.beta.cdf( -0.5, 4.0, 2.0 )\n 0.0\n > y = base.dists.beta.cdf( 1.5, 4.0, 2.0 )\n 1.0\n\n > y = base.dists.beta.cdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.beta.cdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.beta.cdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.beta.cdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.beta.cdf.factory( α, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a beta distribution with first shape parameter `α` and second shape\n parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.beta.cdf.factory( 0.5, 0.5 );\n > var y = mycdf( 0.8 )\n ~0.705\n > y = mycdf( 0.3 )\n ~0.369\n\n"
+base.dists.beta.entropy,"\nbase.dists.beta.entropy( α, β )\n Returns the differential entropy of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Differential entropy.\n\n Examples\n --------\n > var v = base.dists.beta.entropy( 1.0, 1.0 )\n 0.0\n > v = base.dists.beta.entropy( 4.0, 12.0 )\n ~-0.869\n > v = base.dists.beta.entropy( 8.0, 2.0 )\n ~-0.795\n\n > v = base.dists.beta.entropy( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.entropy( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.entropy( 2.0, NaN )\n NaN\n > v = base.dists.beta.entropy( NaN, 2.0 )\n NaN\n\n"
+base.dists.beta.kurtosis,"\nbase.dists.beta.kurtosis( α, β )\n Returns the excess kurtosis of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.beta.kurtosis( 1.0, 1.0 )\n -1.2\n > v = base.dists.beta.kurtosis( 4.0, 12.0 )\n ~0.082\n > v = base.dists.beta.kurtosis( 8.0, 2.0 )\n ~0.490\n\n > v = base.dists.beta.kurtosis( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.kurtosis( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.kurtosis( 2.0, NaN )\n NaN\n > v = base.dists.beta.kurtosis( NaN, 2.0 )\n NaN\n\n"
+base.dists.beta.logcdf,"\nbase.dists.beta.logcdf( x, α, β )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a beta distribution with first shape parameter `α` and second\n shape parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.beta.logcdf( 0.5, 1.0, 1.0 )\n ~-0.693\n > y = base.dists.beta.logcdf( 0.5, 2.0, 4.0 )\n ~-0.208\n > y = base.dists.beta.logcdf( 0.2, 2.0, 2.0 )\n ~-2.263\n > y = base.dists.beta.logcdf( 0.8, 4.0, 4.0 )\n ~-0.034\n > y = base.dists.beta.logcdf( -0.5, 4.0, 2.0 )\n -Infinity\n > y = base.dists.beta.logcdf( 1.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.beta.logcdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.beta.logcdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.beta.logcdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.beta.logcdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.beta.logcdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a beta distribution with first shape\n parameter `α` and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.beta.logcdf.factory( 0.5, 0.5 );\n > var y = mylogcdf( 0.8 )\n ~-0.35\n > y = mylogcdf( 0.3 )\n ~-0.997\n\n"
+base.dists.beta.logpdf,"\nbase.dists.beta.logpdf( x, α, β )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a beta distribution with first shape parameter `α` and second shape\n parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Natural logarithm of the PDF.\n\n Examples\n --------\n > var y = base.dists.beta.logpdf( 0.5, 1.0, 1.0 )\n 0.0\n > y = base.dists.beta.logpdf( 0.5, 2.0, 4.0 )\n ~0.223\n > y = base.dists.beta.logpdf( 0.2, 2.0, 2.0 )\n ~-0.041\n > y = base.dists.beta.logpdf( 0.8, 4.0, 4.0 )\n ~-0.556\n > y = base.dists.beta.logpdf( -0.5, 4.0, 2.0 )\n -Infinity\n > y = base.dists.beta.logpdf( 1.5, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.beta.logpdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.beta.logpdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.beta.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.logpdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.beta.logpdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.beta.logpdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a beta distribution with first shape parameter `α`\n and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n fcn: Function\n Function to evaluate the natural logarithm of the PDF.\n\n Examples\n --------\n > var mylogpdf = base.dists.beta.logpdf.factory( 0.5, 0.5 );\n > var y = mylogpdf( 0.8 )\n ~-0.228\n > y = mylogpdf( 0.3 )\n ~-0.364\n\n"
+base.dists.beta.mean,"\nbase.dists.beta.mean( α, β )\n Returns the expected value of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.beta.mean( 1.0, 1.0 )\n 0.5\n > v = base.dists.beta.mean( 4.0, 12.0 )\n 0.25\n > v = base.dists.beta.mean( 8.0, 2.0 )\n 0.8\n\n"
+base.dists.beta.median,"\nbase.dists.beta.median( α, β )\n Returns the median of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.beta.median( 1.0, 1.0 )\n 0.5\n > v = base.dists.beta.median( 4.0, 12.0 )\n ~0.239\n > v = base.dists.beta.median( 8.0, 2.0 )\n ~0.820\n\n > v = base.dists.beta.median( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.median( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.median( 2.0, NaN )\n NaN\n > v = base.dists.beta.median( NaN, 2.0 )\n NaN\n\n"
+base.dists.beta.mgf,"\nbase.dists.beta.mgf( t, α, β )\n Evaluates the moment-generating function (MGF) for a beta distribution with\n first shape parameter `α` and second shape parameter `β` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.beta.mgf( 0.5, 1.0, 1.0 )\n ~1.297\n > y = base.dists.beta.mgf( 0.5, 2.0, 4.0 )\n ~1.186\n > y = base.dists.beta.mgf( 3.0, 2.0, 2.0 )\n ~5.575\n > y = base.dists.beta.mgf( -0.8, 4.0, 4.0 )\n ~0.676\n\n > y = base.dists.beta.mgf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.beta.mgf( 0.0, 1.0, NaN )\n NaN\n\n > y = base.dists.beta.mgf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.beta.mgf( 2.0, 0.0, 0.5 )\n NaN\n\n > y = base.dists.beta.mgf( 2.0, 0.5, -1.0 )\n NaN\n > y = base.dists.beta.mgf( 2.0, 0.5, 0.0 )\n NaN\n\n\nbase.dists.beta.mgf.factory( α, β )\n Returns a function for evaluating the moment-generating function (MGF) of a\n beta distribution with first shape parameter `α` and second shape parameter\n `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.beta.mgf.factory( 0.5, 0.5 );\n > var y = myMGF( 0.8 )\n ~1.552\n > y = myMGF( 0.3 )\n ~1.168\n\n"
+base.dists.beta.mode,"\nbase.dists.beta.mode( α, β )\n Returns the mode of a beta distribution.\n\n If `α <= 1` or `β <= 1`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.beta.mode( 4.0, 12.0 )\n ~0.214\n > v = base.dists.beta.mode( 8.0, 2.0 )\n ~0.875\n > v = base.dists.beta.mode( 1.0, 1.0 )\n NaN\n\n"
+base.dists.beta.pdf,"\nbase.dists.beta.pdf( x, α, β )\n Evaluates the probability density function (PDF) for a beta distribution\n with first shape parameter `α` and second shape parameter `β` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.beta.pdf( 0.5, 1.0, 1.0 )\n 1.0\n > y = base.dists.beta.pdf( 0.5, 2.0, 4.0 )\n 1.25\n > y = base.dists.beta.pdf( 0.2, 2.0, 2.0 )\n ~0.96\n > y = base.dists.beta.pdf( 0.8, 4.0, 4.0 )\n ~0.573\n > y = base.dists.beta.pdf( -0.5, 4.0, 2.0 )\n 0.0\n > y = base.dists.beta.pdf( 1.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.beta.pdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.beta.pdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.beta.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.pdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.beta.pdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.beta.pdf.factory( α, β )\n Returns a function for evaluating the probability density function (PDF) of\n a beta distribution with first shape parameter `α` and second shape\n parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var mypdf = base.dists.beta.pdf.factory( 0.5, 0.5 );\n > var y = mypdf( 0.8 )\n ~0.796\n > y = mypdf( 0.3 )\n ~0.695\n\n"
+base.dists.beta.quantile,"\nbase.dists.beta.quantile( p, α, β )\n Evaluates the quantile function for a beta distribution with first shape\n parameter `α` and second shape parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input value (probability).\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.beta.quantile( 0.8, 2.0, 1.0 )\n ~0.894\n > y = base.dists.beta.quantile( 0.5, 4.0, 2.0 )\n ~0.686\n > y = base.dists.beta.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.beta.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.beta.quantile( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.beta.quantile( 0.5, 1.0, NaN )\n NaN\n\n > y = base.dists.beta.quantile( 0.5, -1.0, 1.0 )\n NaN\n > y = base.dists.beta.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.beta.quantile.factory( α, β )\n Returns a function for evaluating the quantile function of a beta\n distribution with first shape parameter `α` and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.beta.quantile.factory( 2.0, 2.0 );\n > y = myquantile( 0.8 )\n ~0.713\n > y = myquantile( 0.4 )\n ~0.433\n\n"
+base.dists.beta.skewness,"\nbase.dists.beta.skewness( α, β )\n Returns the skewness of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.beta.skewness( 1.0, 1.0 )\n 0.0\n > v = base.dists.beta.skewness( 4.0, 12.0 )\n ~0.529\n > v = base.dists.beta.skewness( 8.0, 2.0 )\n ~-0.829\n\n > v = base.dists.beta.skewness( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.skewness( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.skewness( 2.0, NaN )\n NaN\n > v = base.dists.beta.skewness( NaN, 2.0 )\n NaN\n\n"
+base.dists.beta.stdev,"\nbase.dists.beta.stdev( α, β )\n Returns the standard deviation of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.beta.stdev( 1.0, 1.0 )\n ~0.289\n > v = base.dists.beta.stdev( 4.0, 12.0 )\n ~0.105\n > v = base.dists.beta.stdev( 8.0, 2.0 )\n ~0.121\n\n > v = base.dists.beta.stdev( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.stdev( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.stdev( 2.0, NaN )\n NaN\n > v = base.dists.beta.stdev( NaN, 2.0 )\n NaN\n\n"
+base.dists.beta.variance,"\nbase.dists.beta.variance( α, β )\n Returns the variance of a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.beta.variance( 1.0, 1.0 )\n ~0.083\n > v = base.dists.beta.variance( 4.0, 12.0 )\n ~0.011\n > v = base.dists.beta.variance( 8.0, 2.0 )\n ~0.015\n\n > v = base.dists.beta.variance( 1.0, -0.1 )\n NaN\n > v = base.dists.beta.variance( -0.1, 1.0 )\n NaN\n\n > v = base.dists.beta.variance( 2.0, NaN )\n NaN\n > v = base.dists.beta.variance( NaN, 2.0 )\n NaN\n\n"
+base.dists.betaprime.BetaPrime,"\nbase.dists.betaprime.BetaPrime( [α, β] )\n Returns a beta prime distribution object.\n\n Parameters\n ----------\n α: number (optional)\n First shape parameter. Must be greater than `0`. Default: `1.0`.\n\n β: number (optional)\n Second shape parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n betaprime: Object\n Distribution instance.\n\n betaprime.alpha: number\n First shape parameter. If set, the value must be greater than `0`.\n\n betaprime.beta: number\n Second shape parameter. If set, the value must be greater than `0`.\n\n betaprime.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n betaprime.mean: number\n Read-only property which returns the expected value.\n\n betaprime.mode: number\n Read-only property which returns the mode.\n\n betaprime.skewness: number\n Read-only property which returns the skewness.\n\n betaprime.stdev: number\n Read-only property which returns the standard deviation.\n\n betaprime.variance: number\n Read-only property which returns the variance.\n\n betaprime.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n betaprime.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n betaprime.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n betaprime.pdf: Function\n Evaluates the probability density function (PDF).\n\n betaprime.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var betaprime = base.dists.betaprime.BetaPrime( 6.0, 5.0 );\n > betaprime.alpha\n 6.0\n > betaprime.beta\n 5.0\n > betaprime.kurtosis\n 44.4\n > betaprime.mean\n 1.5\n > betaprime.mode\n ~0.833\n > betaprime.skewness\n ~3.578\n > betaprime.stdev\n ~1.118\n > betaprime.variance\n 1.25\n > betaprime.cdf( 0.8 )\n ~0.25\n > betaprime.logcdf( 0.8 )\n ~-1.387\n > betaprime.logpdf( 1.0 )\n ~-0.486\n > betaprime.pdf( 1.0 )\n ~0.615\n > betaprime.quantile( 0.8 )\n ~2.06\n\n"
+base.dists.betaprime.cdf,"\nbase.dists.betaprime.cdf( x, α, β )\n Evaluates the cumulative distribution function (CDF) for a beta prime\n distribution with first shape parameter `α` and second shape parameter `β`\n at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.betaprime.cdf( 0.5, 1.0, 1.0 )\n ~0.333\n > y = base.dists.betaprime.cdf( 0.5, 2.0, 4.0 )\n ~0.539\n > y = base.dists.betaprime.cdf( 0.2, 2.0, 2.0 )\n ~0.074\n > y = base.dists.betaprime.cdf( 0.8, 4.0, 4.0 )\n ~0.38\n > y = base.dists.betaprime.cdf( -0.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.betaprime.cdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.betaprime.cdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.betaprime.cdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.betaprime.cdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.betaprime.cdf.factory( α, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a beta prime distribution with first shape parameter `α` and second shape\n parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.betaprime.cdf.factory( 0.5, 0.5 );\n > var y = mycdf( 0.8 )\n ~0.465\n > y = mycdf( 0.3 )\n ~0.319\n\n"
+base.dists.betaprime.kurtosis,"\nbase.dists.betaprime.kurtosis( α, β )\n Returns the excess kurtosis of a beta prime distribution.\n\n If `α <= 0` or `β <= 4`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Kurtosis.\n\n Examples\n --------\n > var v = base.dists.betaprime.kurtosis( 2.0, 6.0 )\n ~26.143\n > v = base.dists.betaprime.kurtosis( 4.0, 12.0 )\n ~5.764\n > v = base.dists.betaprime.kurtosis( 8.0, 6.0 )\n ~19.962\n\n > v = base.dists.betaprime.kurtosis( 1.0, 2.8 )\n NaN\n > v = base.dists.betaprime.kurtosis( 1.0, -0.1 )\n NaN\n > v = base.dists.betaprime.kurtosis( -0.1, 5.0 )\n NaN\n\n > v = base.dists.betaprime.kurtosis( 2.0, NaN )\n NaN\n > v = base.dists.betaprime.kurtosis( NaN, 6.0 )\n NaN\n\n"
+base.dists.betaprime.logcdf,"\nbase.dists.betaprime.logcdf( x, α, β )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a beta prime distribution with first shape parameter `α` and\n second shape parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.betaprime.logcdf( 0.5, 1.0, 1.0 )\n ~-1.099\n > y = base.dists.betaprime.logcdf( 0.5, 2.0, 4.0 )\n ~-0.618\n > y = base.dists.betaprime.logcdf( 0.2, 2.0, 2.0 )\n ~-2.603\n > y = base.dists.betaprime.logcdf( 0.8, 4.0, 4.0 )\n ~-0.968\n > y = base.dists.betaprime.logcdf( -0.5, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.betaprime.logcdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.betaprime.logcdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.betaprime.logcdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.betaprime.logcdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.betaprime.logcdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a beta prime distribution with first shape\n parameter `α` and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.betaprime.logcdf.factory( 0.5, 0.5 );\n > var y = mylogcdf( 0.8 )\n ~-0.767\n > y = mylogcdf( 0.3 )\n ~-1.143\n\n"
+base.dists.betaprime.logpdf,"\nbase.dists.betaprime.logpdf( x, α, β )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a beta prime distribution with first shape parameter `α` and second\n shape parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Natural logarithm of the PDF.\n\n Examples\n --------\n > var y = base.dists.betaprime.logpdf( 0.5, 1.0, 1.0 )\n ~-0.811\n > y = base.dists.betaprime.logpdf( 0.5, 2.0, 4.0 )\n ~-0.13\n > y = base.dists.betaprime.logpdf( 0.2, 2.0, 2.0 )\n ~-0.547\n > y = base.dists.betaprime.logpdf( 0.8, 4.0, 4.0 )\n ~-0.43\n > y = base.dists.betaprime.logpdf( -0.5, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.betaprime.logpdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.betaprime.logpdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.betaprime.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.logpdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.betaprime.logpdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.betaprime.logpdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a beta prime distribution with first shape\n parameter `α` and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n fcn: Function\n Function to evaluate the natural logarithm of the PDF.\n\n Examples\n --------\n > var mylogpdf = base.dists.betaprime.logpdf.factory( 0.5, 0.5 );\n > var y = mylogpdf( 0.8 )\n ~-1.62\n > y = mylogpdf( 0.3 )\n ~-0.805\n\n"
+base.dists.betaprime.mean,"\nbase.dists.betaprime.mean( α, β )\n Returns the expected value of a beta prime distribution.\n\n If `α <= 0` or `β <= 1`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.betaprime.mean( 1.0, 2.0 )\n 1.0\n > v = base.dists.betaprime.mean( 4.0, 12.0 )\n ~0.364\n > v = base.dists.betaprime.mean( 8.0, 2.0 )\n 8.0\n\n"
+base.dists.betaprime.mode,"\nbase.dists.betaprime.mode( α, β )\n Returns the mode of a beta prime distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.betaprime.mode( 1.0, 2.0 )\n 0.0\n > v = base.dists.betaprime.mode( 4.0, 12.0 )\n ~0.231\n > v = base.dists.betaprime.mode( 8.0, 2.0 )\n ~2.333\n\n"
+base.dists.betaprime.pdf,"\nbase.dists.betaprime.pdf( x, α, β )\n Evaluates the probability density function (PDF) for a beta prime\n distribution with first shape parameter `α` and second shape parameter `β`\n at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.betaprime.pdf( 0.5, 1.0, 1.0 )\n ~0.444\n > y = base.dists.betaprime.pdf( 0.5, 2.0, 4.0 )\n ~0.878\n > y = base.dists.betaprime.pdf( 0.2, 2.0, 2.0 )\n ~0.579\n > y = base.dists.betaprime.pdf( 0.8, 4.0, 4.0 )\n ~0.65\n > y = base.dists.betaprime.pdf( -0.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.betaprime.pdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.betaprime.pdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.betaprime.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.pdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.betaprime.pdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.betaprime.pdf.factory( α, β )\n Returns a function for evaluating the probability density function (PDF) of\n a beta prime distribution with first shape parameter `α` and second shape\n parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var mypdf = base.dists.betaprime.pdf.factory( 0.5, 0.5 );\n > var y = mypdf( 0.8 )\n ~0.198\n > y = mypdf( 0.3 )\n ~0.447\n\n"
+base.dists.betaprime.quantile,"\nbase.dists.betaprime.quantile( p, α, β )\n Evaluates the quantile function for a beta prime distribution with first\n shape parameter `α` and second shape parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input value (probability).\n\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.betaprime.quantile( 0.8, 2.0, 1.0 )\n ~8.472\n > y = base.dists.betaprime.quantile( 0.5, 4.0, 2.0 )\n ~2.187\n > y = base.dists.betaprime.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.betaprime.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.quantile( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.betaprime.quantile( 0.5, 1.0, NaN )\n NaN\n\n > y = base.dists.betaprime.quantile( 0.5, -1.0, 1.0 )\n NaN\n > y = base.dists.betaprime.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.betaprime.quantile.factory( α, β )\n Returns a function for evaluating the quantile function of a beta prime\n distribution with first shape parameter `α` and second shape parameter `β`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.betaprime.quantile.factory( 2.0, 2.0 );\n > y = myQuantile( 0.8 )\n ~2.483\n > y = myQuantile( 0.4 )\n ~0.763\n\n"
+base.dists.betaprime.skewness,"\nbase.dists.betaprime.skewness( α, β )\n Returns the skewness of a beta prime distribution.\n\n If `α <= 0` or `β <= 3`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.betaprime.skewness( 2.0, 4.0 )\n ~6.261\n > v = base.dists.betaprime.skewness( 4.0, 12.0 )\n ~1.724\n > v = base.dists.betaprime.skewness( 8.0, 4.0 )\n ~5.729\n\n > v = base.dists.betaprime.skewness( 1.0, 2.8 )\n NaN\n > v = base.dists.betaprime.skewness( 1.0, -0.1 )\n NaN\n > v = base.dists.betaprime.skewness( -0.1, 4.0 )\n NaN\n\n > v = base.dists.betaprime.skewness( 2.0, NaN )\n NaN\n > v = base.dists.betaprime.skewness( NaN, 4.0 )\n NaN\n\n"
+base.dists.betaprime.stdev,"\nbase.dists.betaprime.stdev( α, β )\n Returns the standard deviation of a beta prime distribution.\n\n If `α <= 0` or `β <= 2`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.betaprime.stdev( 1.0, 2.5 )\n ~1.491\n > v = base.dists.betaprime.stdev( 4.0, 12.0 )\n ~0.223\n > v = base.dists.betaprime.stdev( 8.0, 2.5 )\n ~8.219\n\n > v = base.dists.betaprime.stdev( 8.0, 1.0 )\n NaN\n > v = base.dists.betaprime.stdev( 1.0, -0.1 )\n NaN\n > v = base.dists.betaprime.stdev( -0.1, 3.0 )\n NaN\n\n > v = base.dists.betaprime.stdev( 2.0, NaN )\n NaN\n > v = base.dists.betaprime.stdev( NaN, 3.0 )\n NaN\n\n"
+base.dists.betaprime.variance,"\nbase.dists.betaprime.variance( α, β )\n Returns the variance of a beta prime distribution.\n\n If `α <= 0` or `β <= 2`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.betaprime.variance( 1.0, 2.5 )\n ~2.222\n > v = base.dists.betaprime.variance( 4.0, 12.0 )\n ~0.05\n > v = base.dists.betaprime.variance( 8.0, 2.5 )\n ~67.556\n\n > v = base.dists.betaprime.variance( 8.0, 1.0 )\n NaN\n > v = base.dists.betaprime.variance( 1.0, -0.1 )\n NaN\n > v = base.dists.betaprime.variance( -0.1, 3.0 )\n NaN\n\n > v = base.dists.betaprime.variance( 2.0, NaN )\n NaN\n > v = base.dists.betaprime.variance( NaN, 3.0 )\n NaN\n\n"
+base.dists.binomial.Binomial,"\nbase.dists.binomial.Binomial( [n, p] )\n Returns a binomial distribution object.\n\n Parameters\n ----------\n n: integer (optional)\n Number of trials. Must be a positive integer. Default: `1`.\n\n p: number (optional)\n Success probability. Must be a number between `0` and `1`. Default:\n `0.5`.\n\n Returns\n -------\n binomial: Object\n Distribution instance.\n\n binomial.n: number\n Number of trials. If set, the value must be a positive integer.\n\n binomial.p: number\n Success probability. If set, the value must be a number between `0` and\n `1`.\n\n binomial.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n binomial.mean: number\n Read-only property which returns the expected value.\n\n binomial.median: number\n Read-only property which returns the median.\n\n binomial.mode: number\n Read-only property which returns the mode.\n\n binomial.skewness: number\n Read-only property which returns the skewness.\n\n binomial.stdev: number\n Read-only property which returns the standard deviation.\n\n binomial.variance: number\n Read-only property which returns the variance.\n\n binomial.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n binomial.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n binomial.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n binomial.pmf: Function\n Evaluates the probability mass function (PMF).\n\n binomial.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var binomial = base.dists.binomial.Binomial( 8, 0.5 );\n > binomial.n\n 8.0\n > binomial.p\n 0.5\n > binomial.kurtosis\n -0.25\n > binomial.mean\n 4.0\n > binomial.median\n 4.0\n > binomial.mode\n 4.0\n > binomial.skewness\n 0.0\n > binomial.stdev\n ~1.414\n > binomial.variance\n 2.0\n > binomial.cdf( 2.9 )\n ~0.145\n > binomial.logpmf( 3.0 )\n ~-1.52\n > binomial.mgf( 0.2 )\n ~2.316\n > binomial.pmf( 3.0 )\n ~0.219\n > binomial.quantile( 0.8 )\n 5.0\n\n"
+base.dists.binomial.cdf,"\nbase.dists.binomial.cdf( x, n, p )\n Evaluates the cumulative distribution function (CDF) for a binomial\n distribution with number of trials `n` and success probability `p` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.binomial.cdf( 3.0, 20, 0.2 )\n ~0.411\n > y = base.dists.binomial.cdf( 21.0, 20, 0.2 )\n 1.0\n > y = base.dists.binomial.cdf( 5.0, 10, 0.4 )\n ~0.834\n > y = base.dists.binomial.cdf( 0.0, 10, 0.4 )\n ~0.006\n > y = base.dists.binomial.cdf( NaN, 20, 0.5 )\n NaN\n > y = base.dists.binomial.cdf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.binomial.cdf( 0.0, 20, NaN )\n NaN\n > y = base.dists.binomial.cdf( 2.0, 1.5, 0.5 )\n NaN\n > y = base.dists.binomial.cdf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.binomial.cdf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.binomial.cdf( 2.0, 20, 1.5 )\n NaN\n\n\nbase.dists.binomial.cdf.factory( n, p )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a binomial distribution with number of trials `n` and success probability\n `p`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.binomial.cdf.factory( 10, 0.5 );\n > var y = mycdf( 3.0 )\n ~0.172\n > y = mycdf( 1.0 )\n ~0.011\n\n"
+base.dists.binomial.entropy,"\nbase.dists.binomial.entropy( n, p )\n Returns the entropy of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.binomial.entropy( 100, 0.1 )\n ~2.511\n > v = base.dists.binomial.entropy( 20, 0.5 )\n ~2.223\n > v = base.dists.binomial.entropy( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.entropy( 20, 1.1 )\n NaN\n > v = base.dists.binomial.entropy( 20, NaN )\n NaN\n\n"
+base.dists.binomial.kurtosis,"\nbase.dists.binomial.kurtosis( n, p )\n Returns the excess kurtosis of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.binomial.kurtosis( 100, 0.1 )\n ~0.051\n > v = base.dists.binomial.kurtosis( 20, 0.5 )\n ~-0.1\n > v = base.dists.binomial.kurtosis( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.kurtosis( 20, 1.1 )\n NaN\n > v = base.dists.binomial.kurtosis( 20, NaN )\n NaN\n\n"
+base.dists.binomial.logpmf,"\nbase.dists.binomial.logpmf( x, n, p )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n binomial distribution with number of trials `n` and success probability `p`\n at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.binomial.logpmf( 3.0, 20, 0.2 )\n ~-1.583\n > y = base.dists.binomial.logpmf( 21.0, 20, 0.2 )\n -Infinity\n > y = base.dists.binomial.logpmf( 5.0, 10, 0.4 )\n ~-1.606\n > y = base.dists.binomial.logpmf( 0.0, 10, 0.4 )\n ~-5.108\n > y = base.dists.binomial.logpmf( NaN, 20, 0.5 )\n NaN\n > y = base.dists.binomial.logpmf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.binomial.logpmf( 0.0, 20, NaN )\n NaN\n > y = base.dists.binomial.logpmf( 2.0, 1.5, 0.5 )\n NaN\n > y = base.dists.binomial.logpmf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.binomial.logpmf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.binomial.logpmf( 2.0, 20, 1.5 )\n NaN\n\n\nbase.dists.binomial.logpmf.factory( n, p )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a binomial distribution with number of trials `n` and\n success probability `p`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogpmf = base.dists.binomial.logpmf.factory( 10, 0.5 );\n > var y = mylogpmf( 3.0 )\n ~-2.144\n > y = mylogpmf( 5.0 )\n ~-1.402\n\n"
+base.dists.binomial.mean,"\nbase.dists.binomial.mean( n, p )\n Returns the expected value of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.binomial.mean( 100, 0.1 )\n 10.0\n > v = base.dists.binomial.mean( 20, 0.5 )\n 10.0\n > v = base.dists.binomial.mean( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.mean( 20, 1.1 )\n NaN\n > v = base.dists.binomial.mean( 20, NaN )\n NaN\n\n"
+base.dists.binomial.median,"\nbase.dists.binomial.median( n, p )\n Returns the median of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.binomial.median( 100, 0.1 )\n 10\n > v = base.dists.binomial.median( 20, 0.5 )\n 10\n > v = base.dists.binomial.median( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.median( 20, 1.1 )\n NaN\n > v = base.dists.binomial.median( 20, NaN )\n NaN\n\n"
+base.dists.binomial.mgf,"\nbase.dists.binomial.mgf( t, n, p )\n Evaluates the moment-generating function (MGF) for a binomial distribution\n with number of trials `n` and success probability `p` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.binomial.mgf( 0.5, 20, 0.2 )\n ~11.471\n > y = base.dists.binomial.mgf( 5.0, 20, 0.2 )\n ~4.798e+29\n > y = base.dists.binomial.mgf( 0.9, 10, 0.4 )\n ~99.338\n > y = base.dists.binomial.mgf( 0.0, 10, 0.4 )\n 1.0\n\n > y = base.dists.binomial.mgf( NaN, 20, 0.5 )\n NaN\n > y = base.dists.binomial.mgf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.binomial.mgf( 0.0, 20, NaN )\n NaN\n\n > y = base.dists.binomial.mgf( 2.0, 1.5, 0.5 )\n NaN\n > y = base.dists.binomial.mgf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.binomial.mgf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.binomial.mgf( 2.0, 20, 1.5 )\n NaN\n\n\nbase.dists.binomial.mgf.factory( n, p )\n Returns a function for evaluating the moment-generating function (MGF) of a\n binomial distribution with number of trials `n` and success probability `p`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.binomial.mgf.factory( 10, 0.5 );\n > var y = myMGF( 0.3 )\n ~5.013\n\n"
+base.dists.binomial.mode,"\nbase.dists.binomial.mode( n, p )\n Returns the mode of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.binomial.mode( 100, 0.1 )\n 10\n > v = base.dists.binomial.mode( 20, 0.5 )\n 10\n > v = base.dists.binomial.mode( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.mode( 20, 1.1 )\n NaN\n > v = base.dists.binomial.mode( 20, NaN )\n NaN\n\n"
+base.dists.binomial.pmf,"\nbase.dists.binomial.pmf( x, n, p )\n Evaluates the probability mass function (PMF) for a binomial distribution\n with number of trials `n` and success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.binomial.pmf( 3.0, 20, 0.2 )\n ~0.205\n > y = base.dists.binomial.pmf( 21.0, 20, 0.2 )\n 0.0\n > y = base.dists.binomial.pmf( 5.0, 10, 0.4 )\n ~0.201\n > y = base.dists.binomial.pmf( 0.0, 10, 0.4 )\n ~0.006\n > y = base.dists.binomial.pmf( NaN, 20, 0.5 )\n NaN\n > y = base.dists.binomial.pmf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.binomial.pmf( 0.0, 20, NaN )\n NaN\n > y = base.dists.binomial.pmf( 2.0, 1.5, 0.5 )\n NaN\n > y = base.dists.binomial.pmf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.binomial.pmf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.binomial.pmf( 2.0, 20, 1.5 )\n NaN\n\n\nbase.dists.binomial.pmf.factory( n, p )\n Returns a function for evaluating the probability mass function (PMF) of a\n binomial distribution with number of trials `n` and success probability `p`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var mypmf = base.dists.binomial.pmf.factory( 10, 0.5 );\n > var y = mypmf( 3.0 )\n ~0.117\n > y = mypmf( 5.0 )\n ~0.246\n\n"
+base.dists.binomial.quantile,"\nbase.dists.binomial.quantile( r, n, p )\n Evaluates the quantile function for a binomial distribution with number of\n trials `n` and success probability `p` at a probability `r`.\n\n If `r < 0` or `r > 1`, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n r: number\n Input probability.\n\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.binomial.quantile( 0.4, 20, 0.2 )\n 3\n > y = base.dists.binomial.quantile( 0.8, 20, 0.2 )\n 5\n > y = base.dists.binomial.quantile( 0.5, 10, 0.4 )\n 4\n > y = base.dists.binomial.quantile( 0.0, 10, 0.4 )\n 0\n > y = base.dists.binomial.quantile( 1.0, 10, 0.4 )\n 10\n\n > y = base.dists.binomial.quantile( NaN, 20, 0.5 )\n NaN\n > y = base.dists.binomial.quantile( 0.2, NaN, 0.5 )\n NaN\n > y = base.dists.binomial.quantile( 0.2, 20, NaN )\n NaN\n\n > y = base.dists.binomial.quantile( 0.5, 1.5, 0.5 )\n NaN\n > y = base.dists.binomial.quantile( 0.5, -2.0, 0.5 )\n NaN\n\n > y = base.dists.binomial.quantile( 0.5, 20, -1.0 )\n NaN\n > y = base.dists.binomial.quantile( 0.5, 20, 1.5 )\n NaN\n\n\nbase.dists.binomial.quantile.factory( n, p )\n Returns a function for evaluating the quantile function of a binomial\n distribution with number of trials `n` and success probability `p`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.binomial.quantile.factory( 10, 0.5 );\n > var y = myquantile( 0.1 )\n 3\n > y = myquantile( 0.9 )\n 7\n\n"
+base.dists.binomial.skewness,"\nbase.dists.binomial.skewness( n, p )\n Returns the skewness of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.binomial.skewness( 100, 0.1 )\n ~0.267\n > v = base.dists.binomial.skewness( 20, 0.5 )\n 0.0\n > v = base.dists.binomial.skewness( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.skewness( 20, 1.1 )\n NaN\n > v = base.dists.binomial.skewness( 20, NaN )\n NaN\n\n"
+base.dists.binomial.stdev,"\nbase.dists.binomial.stdev( n, p )\n Returns the standard deviation of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.binomial.stdev( 100, 0.1 )\n 3.0\n > v = base.dists.binomial.stdev( 20, 0.5 )\n ~2.236\n > v = base.dists.binomial.stdev( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.stdev( 20, 1.1 )\n NaN\n > v = base.dists.binomial.stdev( 20, NaN )\n NaN\n\n"
+base.dists.binomial.variance,"\nbase.dists.binomial.variance( n, p )\n Returns the variance of a binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a number of trials `n` which is not a nonnegative integer, the\n function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.binomial.variance( 100, 0.1 )\n 9\n > v = base.dists.binomial.variance( 20, 0.5 )\n 5\n > v = base.dists.binomial.variance( 10.3, 0.5 )\n NaN\n > v = base.dists.binomial.variance( 20, 1.1 )\n NaN\n > v = base.dists.binomial.variance( 20, NaN )\n NaN\n\n"
+base.dists.cauchy.Cauchy,"\nbase.dists.cauchy.Cauchy( [x0, Ɣ] )\n Returns a Cauchy distribution object.\n\n Parameters\n ----------\n x0: number (optional)\n Location parameter. Default: `0.0`.\n\n Ɣ: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n cauchy: Object\n Distribution instance.\n\n cauchy.x0: number\n Location parameter.\n\n cauchy.gamma: number\n Scale parameter. If set, the value must be greater than `0`.\n\n cauchy.entropy: number\n Read-only property which returns the differential entropy.\n\n cauchy.median: number\n Read-only property which returns the median.\n\n cauchy.mode: number\n Read-only property which returns the mode.\n\n cauchy.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n cauchy.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n cauchy.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n cauchy.pdf: Function\n Evaluates the probability density function (PDF).\n\n cauchy.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var cauchy = base.dists.cauchy.Cauchy( 0.0, 1.0 );\n > cauchy.x0\n 0.0\n > cauchy.gamma\n 1.0\n > cauchy.entropy\n ~2.531\n > cauchy.median\n 0.0\n > cauchy.mode\n 0.0\n > cauchy.cdf( 0.8 )\n ~0.715\n > cauchy.logcdf( 1.0 )\n ~-0.288\n > cauchy.logpdf( 1.0 )\n ~-1.838\n > cauchy.pdf( 1.0 )\n ~0.159\n > cauchy.quantile( 0.8 )\n ~1.376\n\n"
+base.dists.cauchy.cdf,"\nbase.dists.cauchy.cdf( x, x0, Ɣ )\n Evaluates the cumulative distribution function (CDF) for a Cauchy\n distribution with location parameter `x0` and scale parameter `Ɣ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.cauchy.cdf( 4.0, 0.0, 2.0 )\n ~0.852\n > y = base.dists.cauchy.cdf( 1.0, 0.0, 2.0 )\n ~0.648\n > y = base.dists.cauchy.cdf( 1.0, 3.0, 2.0 )\n 0.25\n > y = base.dists.cauchy.cdf( NaN, 0.0, 2.0 )\n NaN\n > y = base.dists.cauchy.cdf( 1.0, 2.0, NaN )\n NaN\n > y = base.dists.cauchy.cdf( 1.0, NaN, 3.0 )\n NaN\n\n\nbase.dists.cauchy.cdf.factory( x0, Ɣ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Cauchy distribution with location parameter `x0` and scale parameter\n `Ɣ`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.cauchy.cdf.factory( 1.5, 3.0 );\n > var y = myCDF( 1.0 )\n ~0.447\n\n"
+base.dists.cauchy.entropy,"\nbase.dists.cauchy.entropy( x0, Ɣ )\n Returns the differential entropy of a Cauchy distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.cauchy.entropy( 10.0, 7.0 )\n ~4.477\n > v = base.dists.cauchy.entropy( 22.0, 0.5 )\n ~1.838\n > v = base.dists.cauchy.entropy( 10.3, -0.5 )\n NaN\n\n"
+base.dists.cauchy.logcdf,"\nbase.dists.cauchy.logcdf( x, x0, Ɣ )\n Evaluates the natural logarithm of the cumulative distribution function\n (logCDF) for a Cauchy distribution with location parameter `x0` and scale\n parameter `Ɣ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Natural logarithm of the CDF.\n\n Examples\n --------\n > var y = base.dists.cauchy.logcdf( 4.0, 0.0, 2.0 )\n ~-0.16\n > y = base.dists.cauchy.logcdf( 1.0, 0.0, 2.0 )\n ~-0.435\n > y = base.dists.cauchy.logcdf( 1.0, 3.0, 2.0 )\n ~-1.386\n > y = base.dists.cauchy.logcdf( NaN, 0.0, 2.0 )\n NaN\n > y = base.dists.cauchy.logcdf( 1.0, 2.0, NaN )\n NaN\n > y = base.dists.cauchy.logcdf( 1.0, NaN, 3.0 )\n NaN\n\n\nbase.dists.cauchy.logcdf.factory( x0, Ɣ )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (logCDF) of a Cauchy distribution with location\n parameter `x0` and scale parameter `Ɣ`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Function to evaluate the natural logarithm of CDF.\n\n Examples\n --------\n > var mylogCDF = base.dists.cauchy.logcdf.factory( 1.5, 3.0 );\n > var y = mylogCDF( 1.0 )\n ~-0.804\n\n"
+base.dists.cauchy.logpdf,"\nbase.dists.cauchy.logpdf( x, x0, Ɣ )\n Evaluates the natural logarithm of the probability density function (logPDF)\n for a Cauchy distribution with location parameter `x0` and scale parameter\n `Ɣ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Natural logarithm of PDF.\n\n Examples\n --------\n > var y = base.dists.cauchy.logpdf( 2.0, 1.0, 1.0 )\n ~-1.838\n > y = base.dists.cauchy.logpdf( 4.0, 3.0, 0.1 )\n ~-3.457\n > y = base.dists.cauchy.logpdf( 4.0, 3.0, 3.0 )\n ~-2.349\n > y = base.dists.cauchy.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.cauchy.logpdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.cauchy.logpdf( 2.0, 1.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.cauchy.logpdf( 2.0, 1.0, -2.0 )\n NaN\n\n\nbase.dists.cauchy.logpdf.factory( x0, Ɣ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (logPDF) of a Cauchy distribution with location parameter\n `x0` and scale parameter `Ɣ`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Function to evaluate the natural logarithm of the PDF.\n\n Examples\n --------\n > var mylogPDF = base.dists.cauchy.logpdf.factory( 10.0, 2.0 );\n > var y = mylogPDF( 10.0 )\n ~-1.838\n\n"
+base.dists.cauchy.median,"\nbase.dists.cauchy.median( x0, Ɣ )\n Returns the median of a Cauchy distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.cauchy.median( 10.0, 5.0 )\n 10.0\n > v = base.dists.cauchy.median( 7.0, 0.5 )\n 7.0\n > v = base.dists.cauchy.median( 10.3, -0.5 )\n NaN\n\n"
+base.dists.cauchy.mode,"\nbase.dists.cauchy.mode( x0, Ɣ )\n Returns the mode of a Cauchy distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.cauchy.mode( 10.0, 5.0 )\n 10.0\n > v = base.dists.cauchy.mode( 7.0, 0.5 )\n 7.0\n > v = base.dists.cauchy.mode( 10.3, -0.5 )\n NaN\n\n"
+base.dists.cauchy.pdf,"\nbase.dists.cauchy.pdf( x, x0, Ɣ )\n Evaluates the probability density function (PDF) for a Cauchy distribution\n with location parameter `x0` and scale parameter `Ɣ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.cauchy.pdf( 2.0, 1.0, 1.0 )\n ~0.159\n > y = base.dists.cauchy.pdf( 4.0, 3.0, 0.1 )\n ~0.0315\n > y = base.dists.cauchy.pdf( 4.0, 3.0, 3.0 )\n ~0.095\n > y = base.dists.cauchy.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.cauchy.pdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.cauchy.pdf( 2.0, 1.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.cauchy.pdf( 2.0, 1.0, -2.0 )\n NaN\n\n\nbase.dists.cauchy.pdf.factory( x0, Ɣ )\n Returns a function for evaluating the probability density function (PDF) of\n a Cauchy distribution with location parameter `x0` and scale parameter `Ɣ`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.cauchy.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 10.0 )\n ~0.159\n\n"
+base.dists.cauchy.quantile,"\nbase.dists.cauchy.quantile( p, x0, Ɣ )\n Evaluates the quantile function for a Cauchy distribution with location\n parameter `x0` and scale parameter `Ɣ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.cauchy.quantile( 0.3, 2.0, 2.0 )\n ~0.547\n > y = base.dists.cauchy.quantile( 0.8, 10, 2.0 )\n ~12.753\n > y = base.dists.cauchy.quantile( 0.1, 10.0, 2.0 )\n ~3.845\n\n > y = base.dists.cauchy.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.cauchy.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.cauchy.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.cauchy.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.cauchy.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.cauchy.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.cauchy.quantile.factory( x0, Ɣ )\n Returns a function for evaluating the quantile function of a Cauchy\n distribution with location parameter `x0` and scale parameter `Ɣ`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.cauchy.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n 10.0\n\n"
+base.dists.chi.cdf,"\nbase.dists.chi.cdf( x, k )\n Evaluates the cumulative distribution function (CDF) for a chi distribution\n with degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.chi.cdf( 2.0, 3.0 )\n ~0.739\n > y = base.dists.chi.cdf( 1.0, 0.5 )\n ~0.846\n > y = base.dists.chi.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.chi.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.chi.cdf( 0.0, NaN )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chi.cdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chi.cdf( 2.0, 0.0 )\n 1.0\n > y = base.dists.chi.cdf( -2.0, 0.0 )\n 0.0\n > y = base.dists.chi.cdf( 0.0, 0.0 )\n 0.0\n\nbase.dists.chi.cdf.factory( k )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a chi distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.chi.cdf.factory( 1.0 );\n > var y = mycdf( 2.0 )\n ~0.954\n > y = mycdf( 1.2 )\n ~0.77\n\n"
+base.dists.chi.Chi,"\nbase.dists.chi.Chi( [k] )\n Returns a chi distribution object.\n\n Parameters\n ----------\n k: number (optional)\n Degrees of freedom. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n chi: Object\n Distribution instance.\n\n chi.k: number\n Degrees of freedom. If set, the value must be greater than `0`.\n\n chi.entropy: number\n Read-only property which returns the differential entropy.\n\n chi.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n chi.mean: number\n Read-only property which returns the expected value.\n\n chi.mode: number\n Read-only property which returns the mode.\n\n chi.skewness: number\n Read-only property which returns the skewness.\n\n chi.stdev: number\n Read-only property which returns the standard deviation.\n\n chi.variance: number\n Read-only property which returns the variance.\n\n chi.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n chi.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n chi.pdf: Function\n Evaluates the probability density function (PDF).\n\n chi.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var chi = base.dists.chi.Chi( 6.0 );\n > chi.k\n 6.0\n > chi.entropy\n ~1.04\n > chi.kurtosis\n ~0.025\n > chi.mean\n ~2.35\n > chi.mode\n ~2.236\n > chi.skewness\n ~0.318\n > chi.stdev\n ~0.691\n > chi.variance\n ~0.478\n > chi.cdf( 1.0 )\n ~0.014\n > chi.logpdf( 1.5 )\n ~-1.177\n > chi.pdf( 1.5 )\n ~0.308\n > chi.quantile( 0.5 )\n ~2.313\n\n"
+base.dists.chi.entropy,"\nbase.dists.chi.entropy( k )\n Returns the differential entropy of a chi distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.chi.entropy( 11.0 )\n ~1.056\n > v = base.dists.chi.entropy( 1.5 )\n ~0.878\n\n"
+base.dists.chi.kurtosis,"\nbase.dists.chi.kurtosis( k )\n Returns the excess kurtosis of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.chi.kurtosis( 9.0 )\n ~0.011\n > v = base.dists.chi.kurtosis( 1.5 )\n ~0.424\n\n"
+base.dists.chi.logpdf,"\nbase.dists.chi.logpdf( x, k )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a chi distribution with degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.chi.logpdf( 0.3, 4.0 )\n ~-4.35\n > y = base.dists.chi.logpdf( 0.7, 0.7 )\n ~-0.622\n > y = base.dists.chi.logpdf( -1.0, 0.5 )\n -Infinity\n > y = base.dists.chi.logpdf( 0.0, NaN )\n NaN\n > y = base.dists.chi.logpdf( NaN, 2.0 )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chi.logpdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chi.logpdf( 2.0, 0.0, 2.0 )\n -Infinity\n > y = base.dists.chi.logpdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.chi.logpdf.factory( k )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a chi distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.chi.logpdf.factory( 6.0 );\n > var y = mylogPDF( 3.0 )\n ~-1.086\n\n"
+base.dists.chi.mean,"\nbase.dists.chi.mean( k )\n Returns the expected value of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.chi.mean( 11.0 )\n ~3.242\n > v = base.dists.chi.mean( 4.5 )\n ~2.008\n\n"
+base.dists.chi.mode,"\nbase.dists.chi.mode( k )\n Returns the mode of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 1`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.chi.mode( 11.0 )\n ~3.162\n > v = base.dists.chi.mode( 1.5 )\n ~0.707\n\n"
+base.dists.chi.pdf,"\nbase.dists.chi.pdf( x, k )\n Evaluates the probability density function (PDF) for a chi distribution with\n degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.chi.pdf( 0.3, 4.0 )\n ~0.013\n > y = base.dists.chi.pdf( 0.7, 0.7 )\n ~0.537\n > y = base.dists.chi.pdf( -1.0, 0.5 )\n 0.0\n > y = base.dists.chi.pdf( 0.0, NaN )\n NaN\n > y = base.dists.chi.pdf( NaN, 2.0 )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chi.pdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chi.pdf( 2.0, 0.0, 2.0 )\n 0.0\n > y = base.dists.chi.pdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.chi.pdf.factory( k )\n Returns a function for evaluating the probability density function (PDF) of\n a chi distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.chi.pdf.factory( 6.0 );\n > var y = myPDF( 3.0 )\n ~0.337\n\n"
+base.dists.chi.quantile,"\nbase.dists.chi.quantile( p, k )\n Evaluates the quantile function for a chi distribution with degrees of\n freedom `k` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.chi.quantile( 0.8, 1.0 )\n ~1.282\n > y = base.dists.chi.quantile( 0.5, 4.0 )\n ~1.832\n > y = base.dists.chi.quantile( 0.8, 0.1 )\n ~0.116\n > y = base.dists.chi.quantile( -0.2, 0.5 )\n NaN\n > y = base.dists.chi.quantile( 1.1, 0.5 )\n NaN\n > y = base.dists.chi.quantile( NaN, 1.0 )\n NaN\n > y = base.dists.chi.quantile( 0.0, NaN )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chi.quantile( 0.5, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chi.quantile( 0.3, 0.0 )\n 0.0\n > y = base.dists.chi.quantile( 0.9, 0.0 )\n 0.0\n\n\nbase.dists.chi.quantile.factory( k )\n Returns a function for evaluating the quantile function of a chi\n distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.chi.quantile.factory( 2.0 );\n > var y = myquantile( 0.3 )\n ~0.845\n > y = myquantile( 0.7 )\n ~1.552\n\n"
+base.dists.chi.skewness,"\nbase.dists.chi.skewness( k )\n Returns the skewness of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.chi.skewness( 11.0 )\n ~0.225\n > v = base.dists.chi.skewness( 1.5 )\n ~0.763\n\n"
+base.dists.chi.stdev,"\nbase.dists.chi.stdev( k )\n Returns the standard deviation of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.chi.stdev( 11.0 )\n ~0.699\n > v = base.dists.chi.stdev( 1.5 )\n ~0.637\n\n"
+base.dists.chi.variance,"\nbase.dists.chi.variance( k )\n Returns the variance of a chi distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.chi.variance( 11.0 )\n ~0.488\n > v = base.dists.chi.variance( 1.5 )\n ~0.406\n\n"
+base.dists.chisquare.cdf,"\nbase.dists.chisquare.cdf( x, k )\n Evaluates the cumulative distribution function (CDF) for a chi-squared\n distribution with degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.chisquare.cdf( 2.0, 3.0 )\n ~0.428\n > y = base.dists.chisquare.cdf( 1.0, 0.5 )\n ~0.846\n > y = base.dists.chisquare.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.chisquare.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.chisquare.cdf( 0.0, NaN )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chisquare.cdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chisquare.cdf( 2.0, 0.0 )\n 1.0\n > y = base.dists.chisquare.cdf( -2.0, 0.0 )\n 0.0\n > y = base.dists.chisquare.cdf( 0.0, 0.0 )\n 0.0\n\nbase.dists.chisquare.cdf.factory( k )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a chi-squared distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.chisquare.cdf.factory( 1.0 );\n > var y = mycdf( 2.0 )\n ~0.843\n > y = mycdf( 1.2 )\n ~0.727\n\n"
+base.dists.chisquare.ChiSquare,"\nbase.dists.chisquare.ChiSquare( [k] )\n Returns a chi-squared distribution object.\n\n Parameters\n ----------\n k: number (optional)\n Degrees of freedom. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n chisquare: Object\n Distribution instance.\n\n chisquare.k: number\n Degrees of freedom. If set, the value must be greater than `0`.\n\n chisquare.entropy: number\n Read-only property which returns the differential entropy.\n\n chisquare.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n chisquare.mean: number\n Read-only property which returns the expected value.\n\n chisquare.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n chisquare.mode: number\n Read-only property which returns the mode.\n\n chisquare.skewness: number\n Read-only property which returns the skewness.\n\n chisquare.stdev: number\n Read-only property which returns the standard deviation.\n\n chisquare.variance: number\n Read-only property which returns the variance.\n\n chisquare.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n chisquare.pdf: Function\n Evaluates the probability density function (PDF).\n\n chisquare.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var chisquare = base.dists.chisquare.ChiSquare( 6.0 );\n > chisquare.k\n 6.0\n > chisquare.entropy\n ~2.541\n > chisquare.kurtosis\n 2.0\n > chisquare.mean\n 6.0\n > chisquare.mode\n 4.0\n > chisquare.skewness\n ~1.155\n > chisquare.stdev\n ~3.464\n > chisquare.variance\n 12.0\n > chisquare.cdf( 3.0 )\n ~0.191\n > chisquare.mgf( 0.2 )\n ~4.63\n > chisquare.pdf( 1.5 )\n ~0.066\n > chisquare.quantile( 0.5 )\n ~5.348\n\n"
+base.dists.chisquare.entropy,"\nbase.dists.chisquare.entropy( k )\n Returns the differential entropy of a chi-squared distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.chisquare.entropy( 11.0 )\n ~2.901\n > v = base.dists.chisquare.entropy( 1.5 )\n ~1.375\n\n"
+base.dists.chisquare.kurtosis,"\nbase.dists.chisquare.kurtosis( k )\n Returns the excess kurtosis of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.chisquare.kurtosis( 9.0 )\n ~1.333\n > v = base.dists.chisquare.kurtosis( 1.5 )\n 8.0\n\n"
+base.dists.chisquare.logpdf,"\nbase.dists.chisquare.logpdf( x, k )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a chi-squared distribution with degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.chisquare.logpdf( 0.3, 4.0 )\n ~-2.74\n > y = base.dists.chisquare.logpdf( 0.7, 0.7 )\n ~-1.295\n > y = base.dists.chisquare.logpdf( -1.0, 0.5 )\n -Infinity\n > y = base.dists.chisquare.logpdf( 0.0, NaN )\n NaN\n > y = base.dists.chisquare.logpdf( NaN, 2.0 )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chisquare.logpdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chisquare.logpdf( 2.0, 0.0, 2.0 )\n -Infinity\n > y = base.dists.chisquare.logpdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.chisquare.logpdf.factory( k )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a chi-squared distribution with degrees of freedom\n `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var myLogPDF = base.dists.chisquare.logpdf.factory( 6.0 );\n > var y = myLogPDF( 3.0 )\n ~-2.075\n\n"
+base.dists.chisquare.mean,"\nbase.dists.chisquare.mean( k )\n Returns the expected value of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.chisquare.mean( 11.0 )\n 11.0\n > v = base.dists.chisquare.mean( 4.5 )\n 4.5\n\n"
+base.dists.chisquare.mode,"\nbase.dists.chisquare.mode( k )\n Returns the mode of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.chisquare.mode( 11.0 )\n 9.0\n > v = base.dists.chisquare.mode( 1.5 )\n 0.0\n\n"
+base.dists.chisquare.pdf,"\nbase.dists.chisquare.pdf( x, k )\n Evaluates the probability density function (PDF) for a chi-squared\n distribution with degrees of freedom `k` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.chisquare.pdf( 0.3, 4.0 )\n ~0.065\n > y = base.dists.chisquare.pdf( 0.7, 0.7 )\n ~0.274\n > y = base.dists.chisquare.pdf( -1.0, 0.5 )\n 0.0\n > y = base.dists.chisquare.pdf( 0.0, NaN )\n NaN\n > y = base.dists.chisquare.pdf( NaN, 2.0 )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chisquare.pdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chisquare.pdf( 2.0, 0.0, 2.0 )\n 0.0\n > y = base.dists.chisquare.pdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.chisquare.pdf.factory( k )\n Returns a function for evaluating the probability density function (PDF) of\n a chi-squared distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.chisquare.pdf.factory( 6.0 );\n > var y = myPDF( 3.0 )\n ~0.126\n\n"
+base.dists.chisquare.quantile,"\nbase.dists.chisquare.quantile( p, k )\n Evaluates the quantile function for a chi-squared distribution with degrees\n of freedom `k` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.chisquare.quantile( 0.8, 1.0 )\n ~1.642\n > y = base.dists.chisquare.quantile( 0.5, 4.0 )\n ~3.357\n > y = base.dists.chisquare.quantile( 0.8, 0.1 )\n ~0.014\n > y = base.dists.chisquare.quantile( -0.2, 0.5 )\n NaN\n > y = base.dists.chisquare.quantile( 1.1, 0.5 )\n NaN\n > y = base.dists.chisquare.quantile( NaN, 1.0 )\n NaN\n > y = base.dists.chisquare.quantile( 0.0, NaN )\n NaN\n\n // Negative degrees of freedom:\n > y = base.dists.chisquare.quantile( 0.5, -1.0 )\n NaN\n\n // Degenerate distribution when `k = 0`:\n > y = base.dists.chisquare.quantile( 0.3, 0.0 )\n 0.0\n > y = base.dists.chisquare.quantile( 0.9, 0.0 )\n 0.0\n\n\nbase.dists.chisquare.quantile.factory( k )\n Returns a function for evaluating the quantile function of a chi-squared\n distribution with degrees of freedom `k`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.chisquare.quantile.factory( 2.0 );\n > var y = myquantile( 0.3 )\n ~0.713\n > y = myquantile( 0.7 )\n ~2.408\n\n"
+base.dists.chisquare.skewness,"\nbase.dists.chisquare.skewness( k )\n Returns the skewness of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.chisquare.skewness( 11.0 )\n ~0.853\n > v = base.dists.chisquare.skewness( 1.5 )\n ~2.309\n\n"
+base.dists.chisquare.stdev,"\nbase.dists.chisquare.stdev( k )\n Returns the standard deviation of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.chisquare.stdev( 11.0 )\n ~4.69\n > v = base.dists.chisquare.stdev( 1.5 )\n ~1.732\n\n"
+base.dists.chisquare.variance,"\nbase.dists.chisquare.variance( k )\n Returns the variance of a chi-squared distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `k < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.chisquare.variance( 11.0 )\n 22.0\n > v = base.dists.chisquare.variance( 1.5 )\n 3.0\n\n"
+base.dists.cosine.cdf,"\nbase.dists.cosine.cdf( x, μ, s )\n Evaluates the cumulative distribution function (CDF) for a raised cosine\n distribution with location parameter `μ` and scale parameter `s` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.cosine.cdf( 2.0, 0.0, 3.0 )\n ~0.971\n > y = base.dists.cosine.cdf( 9.0, 10.0, 3.0 )\n ~0.196\n\n > y = base.dists.cosine.cdf( 2.0, 0.0, NaN )\n NaN\n > y = base.dists.cosine.cdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.cdf( NaN, 0.0, 1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `s = 0.0`:\n > y = base.dists.cosine.cdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.cosine.cdf( 8.0, 8.0, 0.0 )\n 1.0\n > y = base.dists.cosine.cdf( 10.0, 8.0, 0.0 )\n 1.0\n\n\nbase.dists.cosine.cdf.factory( μ, s )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a raised cosine distribution with location parameter `μ` and scale\n parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.cosine.cdf.factory( 3.0, 1.5 );\n > var y = mycdf( 1.9 )\n ~0.015\n\n"
+base.dists.cosine.Cosine,"\nbase.dists.cosine.Cosine( [μ, s] )\n Returns a raised cosine distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n s: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n cosine: Object\n Distribution instance.\n\n cosine.mu: number\n Location parameter.\n\n cosine.s: number\n Scale parameter. If set, the value must be greater than `0`.\n\n cosine.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n cosine.mean: number\n Read-only property which returns the expected value.\n\n cosine.median: number\n Read-only property which returns the median.\n\n cosine.mode: number\n Read-only property which returns the mode.\n\n cosine.skewness: number\n Read-only property which returns the skewness.\n\n cosine.stdev: number\n Read-only property which returns the standard deviation.\n\n cosine.variance: number\n Read-only property which returns the variance.\n\n cosine.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n cosine.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n cosine.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n cosine.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n cosine.pdf: Function\n Evaluates the probability density function (PDF).\n\n cosine.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var cosine = base.dists.cosine.Cosine( -2.0, 3.0 );\n > cosine.mu\n -2.0\n > cosine.s\n 3.0\n > cosine.kurtosis\n ~-0.594\n > cosine.mean\n -2.0\n > cosine.median\n -2.0\n > cosine.mode\n -2.0\n > cosine.skewness\n 0.0\n > cosine.stdev\n ~1.085\n > cosine.variance\n ~1.176\n > cosine.cdf( 0.5 )\n ~0.996\n > cosine.logcdf( 0.5 )\n ~-0.004\n > cosine.logpdf( -1.0 )\n ~-1.386\n > cosine.mgf( 0.2 )\n ~0.686\n > cosine.pdf( -2.0 )\n ~0.333\n > cosine.quantile( 0.9 )\n ~-0.553\n\n"
+base.dists.cosine.kurtosis,"\nbase.dists.cosine.kurtosis( μ, s )\n Returns the excess kurtosis of a raised cosine distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.cosine.kurtosis( 0.0, 1.0 )\n ~-0.594\n > y = base.dists.cosine.kurtosis( 4.0, 2.0 )\n ~-0.594\n > y = base.dists.cosine.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.cosine.kurtosis( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.logcdf,"\nbase.dists.cosine.logcdf( x, μ, s )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a raised cosine distribution with location parameter `μ` and scale\n parameter `s` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.cosine.logcdf( 2.0, 0.0, 3.0 )\n ~-0.029\n > y = base.dists.cosine.logcdf( 9.0, 10.0, 3.0 )\n ~-1.632\n\n > y = base.dists.cosine.logcdf( 2.0, 0.0, NaN )\n NaN\n > y = base.dists.cosine.logcdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.logcdf( NaN, 0.0, 1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `s = 0.0`:\n > y = base.dists.cosine.logcdf( 2.0, 8.0, 0.0 )\n -Infinity\n > y = base.dists.cosine.logcdf( 8.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.cosine.logcdf( 10.0, 8.0, 0.0 )\n 0.0\n\n\nbase.dists.cosine.logcdf.factory( μ, s )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a raised cosine distribution with location\n parameter `μ` and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.cosine.logcdf.factory( 3.0, 1.5 );\n > var y = mylogcdf( 1.9 )\n ~-4.2\n\n"
+base.dists.cosine.logpdf,"\nbase.dists.cosine.logpdf( x, μ, s )\n Evaluates the logarithm of the probability density function (PDF) for a\n raised cosine distribution with location parameter `μ` and scale parameter\n `s` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.cosine.logpdf( 2.0, 0.0, 3.0 )\n ~-2.485\n > y = base.dists.cosine.logpdf( -1.0, 2.0, 4.0 )\n ~-3.307\n > y = base.dists.cosine.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.cosine.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.logpdf( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.cosine.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution at `s = 0.0`:\n > y = base.dists.cosine.logpdf( 2.0, 8.0, 0.0 )\n -Infinity\n > y = base.dists.cosine.logpdf( 8.0, 8.0, 0.0 )\n Infinity\n\n\nbase.dists.cosine.logpdf.factory( μ, s )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a raised cosine distribution with location parameter `μ`\n and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.cosine.logpdf.factory( 10.0, 2.0 );\n > var y = mylogpdf( 10.0 )\n ~-0.693\n\n"
+base.dists.cosine.mean,"\nbase.dists.cosine.mean( μ, s )\n Returns the expected value of a raised cosine distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.cosine.mean( 0.0, 1.0 )\n 0.0\n > y = base.dists.cosine.mean( 4.0, 2.0 )\n 4.0\n > y = base.dists.cosine.mean( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.mean( 0.0, NaN )\n NaN\n > y = base.dists.cosine.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.median,"\nbase.dists.cosine.median( μ, s )\n Returns the median of a raised cosine distribution with location parameter\n `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.cosine.median( 0.0, 1.0 )\n 0.0\n > y = base.dists.cosine.median( 4.0, 2.0 )\n 4.0\n > y = base.dists.cosine.median( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.median( 0.0, NaN )\n NaN\n > y = base.dists.cosine.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.mgf,"\nbase.dists.cosine.mgf( t, μ, s )\n Evaluates the moment-generating function (MGF) for a raised cosine\n distribution with location parameter `μ` and scale parameter `s` at a value\n `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.cosine.mgf( 2.0, 0.0, 3.0 )\n ~7.234\n > y = base.dists.cosine.mgf( 9.0, 10.0, 3.0 )\n ~1.606e+47\n\n > y = base.dists.cosine.mgf( 0.5, 0.0, NaN )\n NaN\n > y = base.dists.cosine.mgf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.mgf( NaN, 0.0, 1.0 )\n NaN\n\n\nbase.dists.cosine.mgf.factory( μ, s )\n Returns a function for evaluating the moment-generating function (MGF) of a\n raised cosine distribution with location parameter `μ` and scale parameter\n `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.cosine.mgf.factory( 3.0, 1.5 );\n > var y = mymgf( 1.9 )\n ~495.57\n\n"
+base.dists.cosine.mode,"\nbase.dists.cosine.mode( μ, s )\n Returns the mode of a raised cosine distribution with location parameter `μ`\n and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.cosine.mode( 0.0, 1.0 )\n 0.0\n > y = base.dists.cosine.mode( 4.0, 2.0 )\n 4.0\n > y = base.dists.cosine.mode( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.mode( 0.0, NaN )\n NaN\n > y = base.dists.cosine.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.pdf,"\nbase.dists.cosine.pdf( x, μ, s )\n Evaluates the probability density function (PDF) for a raised cosine\n distribution with location parameter `μ` and scale parameter `s` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.cosine.pdf( 2.0, 0.0, 3.0 )\n ~0.083\n > y = base.dists.cosine.pdf( 2.4, 4.0, 2.0 )\n ~0.048\n > y = base.dists.cosine.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.cosine.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.cosine.pdf( 2.0, 0.0, -1.0 )\n NaN\n > y = base.dists.cosine.pdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.cosine.pdf( 8.0, 8.0, 0.0 )\n Infinity\n\n\nbase.dists.cosine.pdf.factory( μ, s )\n Returns a function for evaluating the probability density function (PDF) of\n a raised cosine distribution with location parameter `μ` and scale parameter\n `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.cosine.pdf.factory( 0.0, 3.0 );\n > var y = myPDF( 2.0 )\n ~0.083\n\n"
+base.dists.cosine.quantile,"\nbase.dists.cosine.quantile( p, μ, s )\n Evaluates the quantile function for a raised cosine distribution with\n location parameter `μ` and scale parameter `s` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.cosine.quantile( 0.8, 0.0, 1.0 )\n ~0.327\n > y = base.dists.cosine.quantile( 0.5, 4.0, 2.0 )\n ~4.0\n\n > y = base.dists.cosine.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.cosine.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.cosine.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.cosine.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.cosine.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.cosine.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.cosine.quantile.factory( μ, s )\n Returns a function for evaluating the quantile function of a raised cosine\n distribution with location parameter `μ` and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.cosine.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.3 )\n ~9.586\n\n"
+base.dists.cosine.skewness,"\nbase.dists.cosine.skewness( μ, s )\n Returns the skewness of a raised cosine distribution with location parameter\n `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.cosine.skewness( 0.0, 1.0 )\n 0.0\n > y = base.dists.cosine.skewness( 4.0, 2.0 )\n 0.0\n > y = base.dists.cosine.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.skewness( 0.0, NaN )\n NaN\n > y = base.dists.cosine.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.stdev,"\nbase.dists.cosine.stdev( μ, s )\n Returns the standard deviation of a raised cosine distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.cosine.stdev( 0.0, 1.0 )\n ~0.362\n > y = base.dists.cosine.stdev( 4.0, 2.0 )\n ~0.723\n > y = base.dists.cosine.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.stdev( 0.0, NaN )\n NaN\n > y = base.dists.cosine.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.cosine.variance,"\nbase.dists.cosine.variance( μ, s )\n Returns the variance of a raised cosine distribution with location parameter\n `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.cosine.variance( 0.0, 1.0 )\n ~0.131\n > y = base.dists.cosine.variance( 4.0, 2.0 )\n ~0.523\n > y = base.dists.cosine.variance( NaN, 1.0 )\n NaN\n > y = base.dists.cosine.variance( 0.0, NaN )\n NaN\n > y = base.dists.cosine.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.degenerate.cdf,"\nbase.dists.degenerate.cdf( x, μ )\n Evaluates the cumulative distribution function (CDF) for a degenerate\n distribution with mean value `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.degenerate.cdf( 2.0, 3.0 )\n 0.0\n > y = base.dists.degenerate.cdf( 4.0, 3.0 )\n 1.0\n > y = base.dists.degenerate.cdf( 3.0, 3.0 )\n 1.0\n > y = base.dists.degenerate.cdf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.cdf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.cdf.factory( μ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a degenerate distribution centered at a provided mean value.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.degenerate.cdf.factory( 5.0 );\n > var y = myCDF( 3.0 )\n 0.0\n > y = myCDF( 6.0 )\n 1.0\n\n"
+base.dists.degenerate.Degenerate,"\nbase.dists.degenerate.Degenerate( [μ] )\n Returns a degenerate distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Constant value of distribution.\n\n Returns\n -------\n degenerate: Object\n Distribution instance.\n\n degenerate.mu: number\n Constant value of distribution.\n\n degenerate.entropy: number\n Read-only property which returns the differential entropy.\n\n degenerate.mean: number\n Read-only property which returns the expected value.\n\n degenerate.median: number\n Read-only property which returns the median.\n\n degenerate.stdev: number\n Read-only property which returns the standard deviation.\n\n degenerate.variance: number\n Read-only property which returns the variance.\n\n degenerate.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n degenerate.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n degenerate.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n degenerate.logpmf: Function\n Evaluates the natural logarithm of the probability mass function\n (PMF).\n\n degenerate.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n degenerate.pmf: Function\n Evaluates the probability mass function (PMF).\n\n degenerate.pdf: Function\n Evaluates the probability density function (PDF).\n\n degenerate.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var degenerate = base.dists.degenerate.Degenerate( 2.0 );\n > degenerate.mu\n 2.0\n > degenerate.entropy\n 0.0\n > degenerate.mean\n 2.0\n > degenerate.mode\n 2.0\n > degenerate.median\n 2.0\n > degenerate.stdev\n 0.0\n > degenerate.variance\n 0.0\n > degenerate.cdf( 0.5 )\n 0.0\n > degenerate.logcdf( 2.5 )\n 0.0\n > degenerate.logpdf( 0.5 )\n -Infinity\n > degenerate.logpmf( 2.5 )\n -Infinity\n > degenerate.mgf( 0.2 )\n ~1.492\n > degenerate.pdf( 2.0 )\n +Infinity\n > degenerate.pmf( 2.0 )\n 1.0\n > degenerate.quantile( 0.7 )\n 2.0\n\n"
+base.dists.degenerate.entropy,"\nbase.dists.degenerate.entropy( μ )\n Returns the entropy of a degenerate distribution with constant value `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.degenerate.entropy( 20.0 )\n 0.0\n > v = base.dists.degenerate.entropy( -10.0 )\n 0.0\n\n"
+base.dists.degenerate.logcdf,"\nbase.dists.degenerate.logcdf( x, μ )\n Evaluates the natural logarithm of the cumulative distribution function\n (logCDF) for a degenerate distribution with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Natural logarithm of the CDF.\n\n Examples\n --------\n > var y = base.dists.degenerate.logcdf( 2.0, 3.0 )\n -Infinity\n > y = base.dists.degenerate.logcdf( 4.0, 3.0 )\n 0\n > y = base.dists.degenerate.logcdf( 3.0, 3.0 )\n 0\n > y = base.dists.degenerate.logcdf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.logcdf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.logcdf.factory( μ )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (logCDF) of a degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n logcdf: Function\n Function to evaluate the natural logarithm of cumulative distribution\n function (logCDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.degenerate.logcdf.factory( 5.0 );\n > var y = mylogcdf( 3.0 )\n -Infinity\n > y = mylogcdf( 6.0 )\n 0\n\n"
+base.dists.degenerate.logpdf,"\nbase.dists.degenerate.logpdf( x, μ )\n Evaluates the natural logarithm of the probability density function (logPDF)\n for a degenerate distribution with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Natural logarithm of the PDF.\n\n Examples\n --------\n > var y = base.dists.degenerate.logpdf( 2.0, 3.0 )\n -Infinity\n > y = base.dists.degenerate.logpdf( 3.0, 3.0 )\n Infinity\n > y = base.dists.degenerate.logpdf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.logpdf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.logpdf.factory( μ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (logPDF) of a degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n logpdf: Function\n Function to evaluate the natural logarithm of the PDF.\n\n Examples\n --------\n > var mylogPDF = base.dists.degenerate.logpdf.factory( 10.0 );\n > var y = mylogPDF( 10.0 )\n Infinity\n\n"
+base.dists.degenerate.logpmf,"\nbase.dists.degenerate.logpmf( x, μ )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n degenerate distribution with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.degenerate.logpmf( 2.0, 3.0 )\n -Infinity\n > y = base.dists.degenerate.logpmf( 3.0, 3.0 )\n 0.0\n > y = base.dists.degenerate.logpmf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.logpmf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.logpmf.factory( μ )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogPMF = base.dists.degenerate.logpmf.factory( 10.0 );\n > var y = mylogPMF( 10.0 )\n 0.0\n\n"
+base.dists.degenerate.mean,"\nbase.dists.degenerate.mean( μ )\n Returns the expected value of a degenerate distribution with constant value\n `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.degenerate.mean( 20.0 )\n 20.0\n > v = base.dists.degenerate.mean( -10.0 )\n -10.0\n\n"
+base.dists.degenerate.median,"\nbase.dists.degenerate.median( μ )\n Returns the median of a degenerate distribution with constant value `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.degenerate.median( 20.0 )\n 20.0\n > v = base.dists.degenerate.median( -10.0 )\n -10.0\n\n"
+base.dists.degenerate.mgf,"\nbase.dists.degenerate.mgf( x, μ )\n Evaluates the moment-generating function (MGF) for a degenerate distribution\n with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.degenerate.mgf( 1.0, 1.0 )\n ~2.718\n > y = base.dists.degenerate.mgf( 2.0, 3.0 )\n ~403.429\n > y = base.dists.degenerate.mgf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.mgf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.mgf.factory( μ )\n Returns a function for evaluating the moment-generating function (MGF) of a\n degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.degenerate.mgf.factory( 10.0 );\n > var y = myMGF( 0.1 )\n ~2.718\n\n"
+base.dists.degenerate.mode,"\nbase.dists.degenerate.mode( μ )\n Returns the mode of a degenerate distribution with constant value `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.degenerate.mode( 20.0 )\n 20.0\n > v = base.dists.degenerate.mode( -10.0 )\n -10.0\n\n"
+base.dists.degenerate.pdf,"\nbase.dists.degenerate.pdf( x, μ )\n Evaluates the probability density function (PDF) for a degenerate\n distribution with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.degenerate.pdf( 2.0, 3.0 )\n 0.0\n > y = base.dists.degenerate.pdf( 3.0, 3.0 )\n Infinity\n > y = base.dists.degenerate.pdf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.pdf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.pdf.factory( μ )\n Returns a function for evaluating the probability density function (PDF) of\n a degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.degenerate.pdf.factory( 10.0 );\n > var y = myPDF( 10.0 )\n Infinity\n\n"
+base.dists.degenerate.pmf,"\nbase.dists.degenerate.pmf( x, μ )\n Evaluates the probability mass function (PMF) for a degenerate distribution\n with mean `μ`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.degenerate.pmf( 2.0, 3.0 )\n 0.0\n > y = base.dists.degenerate.pmf( 3.0, 3.0 )\n 1.0\n > y = base.dists.degenerate.pmf( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.pmf( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.pmf.factory( μ )\n Returns a function for evaluating the probability mass function (PMF) of a\n degenerate distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var myPMF = base.dists.degenerate.pmf.factory( 10.0 );\n > var y = myPMF( 10.0 )\n 1.0\n\n"
+base.dists.degenerate.quantile,"\nbase.dists.degenerate.quantile( p, μ )\n Evaluates the quantile function for a degenerate distribution with mean `μ`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` for any argument, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.degenerate.quantile( 0.5, 2.0 )\n 2.0\n > y = base.dists.degenerate.quantile( 0.9, 4.0 )\n 4.0\n > y = base.dists.degenerate.quantile( 1.1, 0.0 )\n NaN\n > y = base.dists.degenerate.quantile( -0.2, 0.0 )\n NaN\n > y = base.dists.degenerate.quantile( NaN, 0.0 )\n NaN\n > y = base.dists.degenerate.quantile( 0.0, NaN )\n NaN\n\n\nbase.dists.degenerate.quantile.factory( μ )\n Returns a function for evaluating the quantile function of a degenerate\n distribution with mean `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.degenerate.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n 10.0\n\n"
+base.dists.degenerate.stdev,"\nbase.dists.degenerate.stdev( μ )\n Returns the standard deviation of a degenerate distribution with constant\n value `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.degenerate.stdev( 20.0 )\n 0.0\n > v = base.dists.degenerate.stdev( -10.0 )\n 0.0\n\n"
+base.dists.degenerate.variance,"\nbase.dists.degenerate.variance( μ )\n Returns the variance of a degenerate distribution with constant value `μ`.\n\n Parameters\n ----------\n μ: number\n Constant value of distribution.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.degenerate.variance( 20.0 )\n 0.0\n > v = base.dists.degenerate.variance( -10.0 )\n 0.0\n\n"
+base.dists.discreteUniform.cdf,"\nbase.dists.discreteUniform.cdf( x, a, b )\n Evaluates the cumulative distribution function (CDF) for a discrete uniform\n distribution with minimum support `a` and maximum support `b` at a value\n `x`.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.cdf( 9.0, 0, 10 )\n ~0.909\n > y = base.dists.discreteUniform.cdf( 0.5, 0, 2 )\n ~0.333\n > y = base.dists.discreteUniform.cdf( PINF, 2, 4 )\n 1.0\n > y = base.dists.discreteUniform.cdf( NINF, 2, 4 )\n 0.0\n > y = base.dists.discreteUniform.cdf( NaN, 0, 1 )\n NaN\n > y = base.dists.discreteUniform.cdf( 0.0, NaN, 1 )\n NaN\n > y = base.dists.discreteUniform.cdf( 0.0, 0, NaN )\n NaN\n > y = base.dists.discreteUniform.cdf( 2.0, 1, 0 )\n NaN\n\n\nbase.dists.discreteUniform.cdf.factory( a, b )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a discrete uniform distribution with minimum support `a` and maximum\n support `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.discreteUniform.cdf.factory( 0, 10 );\n > var y = mycdf( 0.5 )\n ~0.091\n > y = mycdf( 8.0 )\n ~0.818\n\n"
+base.dists.discreteUniform.DiscreteUniform,"\nbase.dists.discreteUniform.DiscreteUniform( [a, b] )\n Returns a discrete uniform distribution object.\n\n Parameters\n ----------\n a: integer (optional)\n Minimum support. Must be an integer smaller than `b`. Default: `0`.\n\n b: integer (optional)\n Maximum support. Must be an integer greater than `a`. Default: `1`.\n\n Returns\n -------\n discreteUniform: Object\n Distribution instance.\n\n discreteUniform.a: integer\n Minimum support. If set, the value must be an integer smaller than or\n equal to `b`.\n\n discreteUniform.b: integer\n Maximum support. If set, the value must be an integer greater than or\n equal to `a`.\n\n discreteUniform.entropy: number\n Read-only property which returns the entropy.\n\n discreteUniform.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n discreteUniform.mean: number\n Read-only property which returns the expected value.\n\n discreteUniform.median: number\n Read-only property which returns the median.\n\n discreteUniform.skewness: number\n Read-only property which returns the skewness.\n\n discreteUniform.stdev: number\n Read-only property which returns the standard deviation.\n\n discreteUniform.variance: number\n Read-only property which returns the variance.\n\n discreteUniform.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n discreteUniform.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n discreteUniform.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n discreteUniform.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n discreteUniform.pmf: Function\n Evaluates the probability mass function (PMF).\n\n discreteUniform.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var discreteUniform = base.dists.discreteUniform.DiscreteUniform( -2, 2 );\n > discreteUniform.a\n -2\n > discreteUniform.b\n 2\n > discreteUniform.entropy\n ~1.609\n > discreteUniform.kurtosis\n -1.3\n > discreteUniform.mean\n 0.0\n > discreteUniform.median\n 0.0\n > discreteUniform.skewness\n 0.0\n > discreteUniform.stdev\n ~1.414\n > discreteUniform.variance\n 2.0\n > discreteUniform.cdf( 0.8 )\n 0.6\n > discreteUniform.logcdf( 0.5 )\n ~-0.511\n > discreteUniform.logpmf( 1.0 )\n ~-1.609\n > discreteUniform.mgf( 0.8 )\n ~1.766\n > discreteUniform.pmf( 0.0 )\n 0.2\n > discreteUniform.quantile( 0.8 )\n 2.0\n\n"
+base.dists.discreteUniform.kurtosis,"\nbase.dists.discreteUniform.kurtosis( a, b )\n Returns the excess kurtosis of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.kurtosis( 0, 1 )\n -2.0\n > v = base.dists.discreteUniform.kurtosis( 4, 12 )\n ~-1.23\n > v = base.dists.discreteUniform.kurtosis( -4, 8 )\n ~-1.214\n\n"
+base.dists.discreteUniform.logcdf,"\nbase.dists.discreteUniform.logcdf( x, a, b )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a discrete uniform distribution with minimum support `a` and\n maximum support `b` at a value `x`.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.logcdf( 9.0, 0, 10 )\n ~-0.095\n > y = base.dists.discreteUniform.logcdf( 0.5, 0, 2 )\n ~-1.099\n > y = base.dists.discreteUniform.logcdf( PINF, 2, 4 )\n 0.0\n > y = base.dists.discreteUniform.logcdf( NINF, 2, 4 )\n -Infinity\n > y = base.dists.discreteUniform.logcdf( NaN, 0, 1 )\n NaN\n > y = base.dists.discreteUniform.logcdf( 0.0, NaN, 1 )\n NaN\n > y = base.dists.discreteUniform.logcdf( 0.0, 0, NaN )\n NaN\n > y = base.dists.discreteUniform.logcdf( 2.0, 1, 0 )\n NaN\n\n\nbase.dists.discreteUniform.logcdf.factory( a, b )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a discrete uniform distribution with minimum\n support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var myLogCDF = base.dists.discreteUniform.logcdf.factory( 0, 10 );\n > var y = myLogCDF( 0.5 )\n ~-2.398\n > y = myLogCDF( 8.0 )\n ~-0.201\n\n"
+base.dists.discreteUniform.logpmf,"\nbase.dists.discreteUniform.logpmf( x, a, b )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n discrete uniform distribution with minimum support `a` and maximum support\n `b` at a value `x`.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.logpmf( 2.0, 0, 4 )\n ~-1.609\n > y = base.dists.discreteUniform.logpmf( 5.0, 0, 4 )\n -Infinity\n > y = base.dists.discreteUniform.logpmf( 3.0, -4, 4 )\n ~-2.197\n > y = base.dists.discreteUniform.logpmf( NaN, 0, 1 )\n NaN\n > y = base.dists.discreteUniform.logpmf( 0.0, NaN, 1 )\n NaN\n > y = base.dists.discreteUniform.logpmf( 0.0, 0, NaN )\n NaN\n > y = base.dists.discreteUniform.logpmf( 2.0, 3, 1 )\n NaN\n > y = base.dists.discreteUniform.logpmf( 2.0, 1, 2.4 )\n NaN\n\n\nbase.dists.discreteUniform.logpmf.factory( a, b )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a discrete uniform distribution with minimum support\n `a` and maximum support `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var myLogPMF = base.dists.discreteUniform.logpmf.factory( 6, 7 );\n > var y = myLogPMF( 7.0 )\n ~-0.693\n > y = myLogPMF( 5.0 )\n -Infinity\n\n"
+base.dists.discreteUniform.mean,"\nbase.dists.discreteUniform.mean( a, b )\n Returns the expected value of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.mean( -2, 2 )\n 0.0\n > v = base.dists.discreteUniform.mean( 4, 12 )\n 8.0\n > v = base.dists.discreteUniform.mean( 2, 8 )\n 5.0\n\n"
+base.dists.discreteUniform.median,"\nbase.dists.discreteUniform.median( a, b )\n Returns the median of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.median( -2, 2 )\n 0.0\n > v = base.dists.discreteUniform.median( 4, 12 )\n 8.0\n > v = base.dists.discreteUniform.median( 2, 8 )\n 5.0\n\n"
+base.dists.discreteUniform.mgf,"\nbase.dists.discreteUniform.mgf( t, a, b )\n Evaluates the moment-generating function (MGF) for a discrete uniform\n distribution with minimum support `a` and maximum support `b` at a value\n `t`.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.mgf( 2.0, 0, 4 )\n ~689.475\n > y = base.dists.discreteUniform.mgf( -0.2, 0, 4 )\n ~0.697\n > y = base.dists.discreteUniform.mgf( 2.0, 0, 1 )\n ~4.195\n > y = base.dists.discreteUniform.mgf( 0.5, 3, 2 )\n NaN\n > y = base.dists.discreteUniform.mgf( NaN, 0, 1 )\n NaN\n > y = base.dists.discreteUniform.mgf( 0.0, NaN, 1 )\n NaN\n > y = base.dists.discreteUniform.mgf( 0.0, 0, NaN )\n NaN\n\n\nbase.dists.discreteUniform.mgf.factory( a, b )\n Returns a function for evaluating the moment-generating function (MGF)\n of a discrete uniform distribution with minimum support `a` and maximum\n support `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.discreteUniform.mgf.factory( 6, 7 );\n > var y = mymgf( 0.1 )\n ~1.918\n > y = mymgf( 1.1 )\n ~1471.722\n\n"
+base.dists.discreteUniform.pmf,"\nbase.dists.discreteUniform.pmf( x, a, b )\n Evaluates the probability mass function (PMF) for a discrete uniform\n distribution with minimum support `a` and maximum support `b` at a value\n `x`.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.pmf( 2.0, 0, 4 )\n ~0.2\n > y = base.dists.discreteUniform.pmf( 5.0, 0, 4 )\n 0.0\n > y = base.dists.discreteUniform.pmf( 3.0, -4, 4 )\n ~0.111\n > y = base.dists.discreteUniform.pmf( NaN, 0, 1 )\n NaN\n > y = base.dists.discreteUniform.pmf( 0.0, NaN, 1 )\n NaN\n > y = base.dists.discreteUniform.pmf( 0.0, 0, NaN )\n NaN\n > y = base.dists.discreteUniform.pmf( 2.0, 3, 1 )\n NaN\n > y = base.dists.discreteUniform.pmf( 2.0, 1, 2.4 )\n NaN\n\n\nbase.dists.discreteUniform.pmf.factory( a, b )\n Returns a function for evaluating the probability mass function (PMF) of\n a discrete uniform distribution with minimum support `a` and maximum support\n `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var myPMF = base.dists.discreteUniform.pmf.factory( 6, 7 );\n > var y = myPMF( 7.0 )\n 0.5\n > y = myPMF( 5.0 )\n 0.0\n\n"
+base.dists.discreteUniform.quantile,"\nbase.dists.discreteUniform.quantile( p, a, b )\n Evaluates the quantile function for a discrete uniform distribution with\n minimum support `a` and maximum support `b` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n If provided `a > b`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.discreteUniform.quantile( 0.8, 0, 1 )\n 1\n > y = base.dists.discreteUniform.quantile( 0.5, 0.0, 10.0 )\n 5\n\n > y = base.dists.discreteUniform.quantile( 1.1, 0, 4 )\n NaN\n > y = base.dists.discreteUniform.quantile( -0.2, 0, 4 )\n NaN\n\n > y = base.dists.discreteUniform.quantile( NaN, -2, 2 )\n NaN\n > y = base.dists.discreteUniform.quantile( 0.1, NaN, 2 )\n NaN\n > y = base.dists.discreteUniform.quantile( 0.1, -2, NaN )\n NaN\n\n > y = base.dists.discreteUniform.quantile( 0.5, 2, 1 )\n NaN\n\n\nbase.dists.discreteUniform.quantile.factory( a, b )\n Returns a function for evaluating the quantile function of a discrete\n uniform distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.discreteUniform.quantile.factory( 0, 4 );\n > var y = myQuantile( 0.8 )\n 4\n\n"
+base.dists.discreteUniform.skewness,"\nbase.dists.discreteUniform.skewness( a, b )\n Returns the skewness of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.skewness( -2, 2 )\n 0.0\n > v = base.dists.discreteUniform.skewness( 4, 12 )\n 0.0\n > v = base.dists.discreteUniform.skewness( 2, 8 )\n 0.0\n\n"
+base.dists.discreteUniform.stdev,"\nbase.dists.discreteUniform.stdev( a, b )\n Returns the standard deviation of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.stdev( 0, 1 )\n ~0.5\n > v = base.dists.discreteUniform.stdev( 4, 12 )\n ~2.582\n > v = base.dists.discreteUniform.stdev( 2, 8 )\n 2.0\n\n"
+base.dists.discreteUniform.variance,"\nbase.dists.discreteUniform.variance( a, b )\n Returns the variance of a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.discreteUniform.variance( 0, 1 )\n ~0.25\n > v = base.dists.discreteUniform.variance( 4, 12 )\n ~6.667\n > v = base.dists.discreteUniform.variance( 2, 8 )\n 4.0\n\n"
+base.dists.erlang.cdf,"\nbase.dists.erlang.cdf( x, k, λ )\n Evaluates the cumulative distribution function (CDF) for an Erlang\n distribution with shape parameter `k` and rate parameter `λ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a nonnegative integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.erlang.cdf( 2.0, 1, 1.0 )\n ~0.865\n > y = base.dists.erlang.cdf( 2.0, 3, 1.0 )\n ~0.323\n > y = base.dists.erlang.cdf( 2.0, 2.5, 1.0 )\n NaN\n > y = base.dists.erlang.cdf( -1.0, 2, 2.0 )\n 0.0\n > y = base.dists.erlang.cdf( PINF, 4, 2.0 )\n 1.0\n > y = base.dists.erlang.cdf( NINF, 4, 2.0 )\n 0.0\n > y = base.dists.erlang.cdf( NaN, 0, 1.0 )\n NaN\n > y = base.dists.erlang.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.erlang.cdf( 0.0, 0, NaN )\n NaN\n > y = base.dists.erlang.cdf( 2.0, -1, 1.0 )\n NaN\n > y = base.dists.erlang.cdf( 2.0, 1, -1.0 )\n NaN\n\n\nbase.dists.erlang.cdf.factory( k, λ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of an Erlang distribution with shape parameter `k` and rate parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.erlang.cdf.factory( 2, 0.5 );\n > var y = mycdf( 6.0 )\n ~0.801\n > y = mycdf( 2.0 )\n ~0.264\n\n"
+base.dists.erlang.entropy,"\nbase.dists.erlang.entropy( k, λ )\n Returns the differential entropy of an Erlang distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.erlang.entropy( 1, 1.0 )\n ~1.0\n > v = base.dists.erlang.entropy( 4, 12.0 )\n ~-0.462\n > v = base.dists.erlang.entropy( 8, 2.0 )\n ~1.723\n\n"
+base.dists.erlang.Erlang,"\nbase.dists.erlang.Erlang( [k, λ] )\n Returns an Erlang distribution object.\n\n Parameters\n ----------\n k: number (optional)\n Shape parameter. Must be a positive integer. Default: `1.0`.\n\n λ: number (optional)\n Rate parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n erlang: Object\n Distribution instance.\n\n erlang.k: number\n Shape parameter. If set, the value must be a positive integer.\n\n erlang.lambda: number\n Rate parameter. If set, the value must be greater than `0`.\n\n erlang.entropy: number\n Read-only property which returns the differential entropy.\n\n erlang.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n erlang.mean: number\n Read-only property which returns the expected value.\n\n erlang.mode: number\n Read-only property which returns the mode.\n\n erlang.skewness: number\n Read-only property which returns the skewness.\n\n erlang.stdev: number\n Read-only property which returns the standard deviation.\n\n erlang.variance: number\n Read-only property which returns the variance.\n\n erlang.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n erlang.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n erlang.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n erlang.pdf: Function\n Evaluates the probability density function (PDF).\n\n erlang.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var erlang = base.dists.erlang.Erlang( 6, 5.0 );\n > erlang.k\n 6\n > erlang.lambda\n 5.0\n > erlang.entropy\n ~0.647\n > erlang.kurtosis\n 1.0\n > erlang.mean\n 1.2\n > erlang.mode\n 1.0\n > erlang.skewness\n ~0.816\n > erlang.stdev\n ~0.49\n > erlang.variance\n 0.24\n > erlang.cdf( 3.0 )\n ~0.997\n > erlang.logpdf( 3.0 )\n ~-4.638\n > erlang.mgf( -0.5 )\n ~0.564\n > erlang.pdf( 3.0 )\n ~0.01\n > erlang.quantile( 0.8 )\n ~1.581\n\n"
+base.dists.erlang.kurtosis,"\nbase.dists.erlang.kurtosis( k, λ )\n Returns the excess kurtosis of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.erlang.kurtosis( 1, 1.0 )\n 6.0\n > v = base.dists.erlang.kurtosis( 4, 12.0 )\n 1.5\n > v = base.dists.erlang.kurtosis( 8, 2.0 )\n 0.75\n\n"
+base.dists.erlang.logpdf,"\nbase.dists.erlang.logpdf( x, k, λ )\n Evaluates the natural logarithm of the probability density function (PDF)\n for an Erlang distribution with shape parameter `k` and rate parameter `λ`\n at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a nonnegative integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.erlang.logpdf( 0.1, 1, 1.0 )\n ~-0.1\n > y = base.dists.erlang.logpdf( 0.5, 2, 2.5 )\n ~-0.111\n > y = base.dists.erlang.logpdf( -1.0, 4, 2.0 )\n -Infinity\n > y = base.dists.erlang.logpdf( NaN, 1, 1.0 )\n NaN\n > y = base.dists.erlang.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.erlang.logpdf( 0.0, 1, NaN )\n NaN\n > y = base.dists.erlang.logpdf( 2.0, -2, 0.5 )\n NaN\n > y = base.dists.erlang.logpdf( 2.0, 0.5, 0.5 )\n NaN\n > y = base.dists.erlang.logpdf( 2.0, 0.0, 2.0 )\n -Infinity\n > y = base.dists.erlang.logpdf( 0.0, 0.0, 2.0 )\n Infinity\n > y = base.dists.erlang.logpdf( 2.0, 1, 0.0 )\n NaN\n > y = base.dists.erlang.logpdf( 2.0, 1, -1.0 )\n NaN\n\n\nbase.dists.erlang.logpdf.factory( k, λ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of an Erlang distribution with shape parameter `k`\n and rate parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var myLogPDF = base.dists.erlang.logpdf.factory( 6.0, 7.0 );\n > y = myLogPDF( 7.0 )\n ~-32.382\n\n\n"
+base.dists.erlang.mean,"\nbase.dists.erlang.mean( k, λ )\n Returns the expected value of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.erlang.mean( 1, 1.0 )\n 1.0\n > v = base.dists.erlang.mean( 4, 12.0 )\n ~0.333\n > v = base.dists.erlang.mean( 8, 2.0 )\n 4.0\n\n"
+base.dists.erlang.mgf,"\nbase.dists.erlang.mgf( t, k, λ )\n Evaluates the moment-generating function (MGF) for an Erlang distribution\n with shape parameter `k` and rate parameter `λ` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a nonnegative integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.erlang.mgf( 0.3, 1, 1.0 )\n ~1.429\n > y = base.dists.erlang.mgf( 2.0, 2, 3.0 )\n ~9.0\n > y = base.dists.erlang.mgf( -1.0, 2, 2.0 )\n ~0.444\n\n > y = base.dists.erlang.mgf( NaN, 1, 1.0 )\n NaN\n > y = base.dists.erlang.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.erlang.mgf( 0.0, 1, NaN )\n NaN\n\n > y = base.dists.erlang.mgf( 0.2, -2, 0.5 )\n NaN\n > y = base.dists.erlang.mgf( 0.2, 0.5, 0.5 )\n NaN\n\n > y = base.dists.erlang.mgf( 0.2, 1, 0.0 )\n NaN\n > y = base.dists.erlang.mgf( 0.2, 1, -5.0 )\n NaN\n\n\nbase.dists.erlang.mgf.factory( k, λ )\n Returns a function for evaluating the moment-generating function (MGF) of an\n Erlang distribution with shape parameter `k` and rate parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.erlang.mgf.factory( 2, 0.5 );\n > var y = myMGF( 0.2 )\n ~2.778\n > y = myMGF( -0.5 )\n 0.25\n\n"
+base.dists.erlang.mode,"\nbase.dists.erlang.mode( k, λ )\n Returns the mode of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.erlang.mode( 1, 1.0 )\n 0.0\n > v = base.dists.erlang.mode( 4, 12.0 )\n 0.25\n > v = base.dists.erlang.mode( 8, 2.0 )\n 3.5\n\n"
+base.dists.erlang.pdf,"\nbase.dists.erlang.pdf( x, k, λ )\n Evaluates the probability density function (PDF) for an Erlang distribution\n with shape parameter `k` and rate parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a nonnegative integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.erlang.pdf( 0.1, 1, 1.0 )\n ~0.905\n > y = base.dists.erlang.pdf( 0.5, 2, 2.5 )\n ~0.895\n > y = base.dists.erlang.pdf( -1.0, 4, 2.0 )\n 0.0\n > y = base.dists.erlang.pdf( NaN, 1, 1.0 )\n NaN\n > y = base.dists.erlang.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.erlang.pdf( 0.0, 1, NaN )\n NaN\n > y = base.dists.erlang.pdf( 2.0, -2, 0.5 )\n NaN\n > y = base.dists.erlang.pdf( 2.0, 0.5, 0.5 )\n NaN\n > y = base.dists.erlang.pdf( 2.0, 0.0, 2.0 )\n 0.0\n > y = base.dists.erlang.pdf( 0.0, 0.0, 2.0 )\n Infinity\n > y = base.dists.erlang.pdf( 2.0, 1, 0.0 )\n NaN\n > y = base.dists.erlang.pdf( 2.0, 1, -1.0 )\n NaN\n\n\nbase.dists.erlang.pdf.factory( k, λ )\n Returns a function for evaluating the probability density function (PDF)\n of an Erlang distribution with shape parameter `k` and rate parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.erlang.pdf.factory( 6.0, 7.0 );\n > y = myPDF( 7.0 )\n ~8.639e-15\n\n\n"
+base.dists.erlang.quantile,"\nbase.dists.erlang.quantile( p, k, λ )\n Evaluates the quantile function for an Erlang distribution with shape\n parameter `k` and rate parameter `λ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a nonnegative integer for `k`, the function returns `NaN`.\n\n If provided a non-positive number for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.erlang.quantile( 0.8, 2, 1.0 )\n ~2.994\n > y = base.dists.erlang.quantile( 0.5, 4, 2.0 )\n ~1.836\n\n > y = base.dists.erlang.quantile( 1.1, 1, 1.0 )\n NaN\n > y = base.dists.erlang.quantile( -0.2, 1, 1.0 )\n NaN\n\n > y = base.dists.erlang.quantile( NaN, 1, 1.0 )\n NaN\n > y = base.dists.erlang.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.erlang.quantile( 0.0, 1, NaN )\n NaN\n\n // Non-integer shape parameter:\n > y = base.dists.erlang.quantile( 0.5, 0.5, 1.0 )\n NaN\n // Non-positive shape parameter:\n > y = base.dists.erlang.quantile( 0.5, -1, 1.0 )\n NaN\n // Non-positive rate parameter:\n > y = base.dists.erlang.quantile( 0.5, 1, -1.0 )\n NaN\n\n\nbase.dists.erlang.quantile.factory( k, λ )\n Returns a function for evaluating the quantile function of an Erlang\n distribution with shape parameter `k` and rate parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.erlang.quantile.factory( 10, 2.0 );\n > var y = myQuantile( 0.4 )\n ~4.452\n\n"
+base.dists.erlang.skewness,"\nbase.dists.erlang.skewness( k, λ )\n Returns the skewness of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.erlang.skewness( 1, 1.0 )\n 2.0\n > v = base.dists.erlang.skewness( 4, 12.0 )\n 1.0\n > v = base.dists.erlang.skewness( 8, 2.0 )\n ~0.707\n\n"
+base.dists.erlang.stdev,"\nbase.dists.erlang.stdev( k, λ )\n Returns the standard deviation of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.erlang.stdev( 1, 1.0 )\n 1.0\n > v = base.dists.erlang.stdev( 4, 12.0 )\n ~0.167\n > v = base.dists.erlang.stdev( 8, 2.0 )\n ~1.414\n\n"
+base.dists.erlang.variance,"\nbase.dists.erlang.variance( k, λ )\n Returns the variance of an Erlang distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If not provided a positive integer for `k`, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.erlang.variance( 1, 1.0 )\n 1.0\n > v = base.dists.erlang.variance( 4, 12.0 )\n ~0.028\n > v = base.dists.erlang.variance( 8, 2.0 )\n 2.0\n\n"
+base.dists.exponential.cdf,"\nbase.dists.exponential.cdf( x, λ )\n Evaluates the cumulative distribution function (CDF) for an exponential\n distribution with rate parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.exponential.cdf( 2.0, 0.1 )\n ~0.181\n > y = base.dists.exponential.cdf( 1.0, 2.0 )\n ~0.865\n > y = base.dists.exponential.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.exponential.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.exponential.cdf( 0.0, NaN )\n NaN\n\n // Negative rate parameter:\n > y = base.dists.exponential.cdf( 2.0, -1.0 )\n NaN\n\nbase.dists.exponential.cdf.factory( λ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n for an exponential distribution with rate parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.exponential.cdf.factory( 0.5 );\n > var y = myCDF( 3.0 )\n ~0.777\n\n"
+base.dists.exponential.entropy,"\nbase.dists.exponential.entropy( λ )\n Returns the differential entropy of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.exponential.entropy( 11.0 )\n ~-1.398\n > v = base.dists.exponential.entropy( 4.5 )\n ~-0.504\n\n"
+base.dists.exponential.Exponential,"\nbase.dists.exponential.Exponential( [λ] )\n Returns an exponential distribution object.\n\n Parameters\n ----------\n λ: number (optional)\n Rate parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n exponential: Object\n Distribution instance.\n\n exponential.lambda: number\n Rate parameter. If set, the value must be greater than `0`.\n\n exponential.entropy: number\n Read-only property which returns the differential entropy.\n\n exponential.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n exponential.mean: number\n Read-only property which returns the expected value.\n\n exponential.median: number\n Read-only property which returns the median.\n\n exponential.mode: number\n Read-only property which returns the mode.\n\n exponential.skewness: number\n Read-only property which returns the skewness.\n\n exponential.stdev: number\n Read-only property which returns the standard deviation.\n\n exponential.variance: number\n Read-only property which returns the variance.\n\n exponential.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n exponential.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n exponential.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n exponential.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n exponential.pdf: Function\n Evaluates the probability density function (PDF).\n\n exponential.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var exponential = base.dists.exponential.Exponential( 6.0 );\n > exponential.lambda\n 6.0\n > exponential.entropy\n ~-0.792\n > exponential.kurtosis\n 6.0\n > exponential.mean\n ~0.167\n > exponential.median\n ~0.116\n > exponential.mode\n 0.0\n > exponential.skewness\n 2.0\n > exponential.stdev\n ~0.167\n > exponential.variance\n ~0.028\n > exponential.cdf( 1.0 )\n ~0.998\n > exponential.logcdf( 1.0 )\n ~-0.002\n > exponential.logpdf( 1.5 )\n ~-7.208\n > exponential.mgf( -0.5 )\n ~0.923\n > exponential.pdf( 1.5 )\n ~0.001\n > exponential.quantile( 0.5 )\n ~0.116\n\n"
+base.dists.exponential.kurtosis,"\nbase.dists.exponential.kurtosis( λ )\n Returns the excess kurtosis of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.exponential.kurtosis( 11.0 )\n 6.0\n > v = base.dists.exponential.kurtosis( 4.5 )\n 6.0\n\n"
+base.dists.exponential.logcdf,"\nbase.dists.exponential.logcdf( x, λ )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for an exponential distribution with rate parameter `λ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.exponential.logcdf( 2.0, 0.1 )\n ~-1.708\n > y = base.dists.exponential.logcdf( 1.0, 2.0 )\n ~-0.145\n > y = base.dists.exponential.logcdf( -1.0, 4.0 )\n -Infinity\n > y = base.dists.exponential.logcdf( NaN, 1.0 )\n NaN\n > y = base.dists.exponential.logcdf( 0.0, NaN )\n NaN\n\n // Negative rate parameter:\n > y = base.dists.exponential.logcdf( 2.0, -1.0 )\n NaN\n\nbase.dists.exponential.logcdf.factory( λ )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) for an exponential distribution with rate\n parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogCDF = base.dists.exponential.logcdf.factory( 0.5 );\n > var y = mylogCDF( 3.0 )\n ~-0.252\n\n"
+base.dists.exponential.logpdf,"\nbase.dists.exponential.logpdf( x, λ )\n Evaluates the natural logarithm of the probability density function (PDF)\n for an exponential distribution with rate parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.exponential.logpdf( 0.3, 4.0 )\n ~0.186\n > y = base.dists.exponential.logpdf( 2.0, 0.7 )\n ~-1.757\n > y = base.dists.exponential.logpdf( -1.0, 0.5 )\n -Infinity\n > y = base.dists.exponential.logpdf( 0, NaN )\n NaN\n > y = base.dists.exponential.logpdf( NaN, 2.0 )\n NaN\n\n // Negative rate:\n > y = base.dists.exponential.logpdf( 2.0, -1.0 )\n NaN\n\nbase.dists.exponential.logpdf.factory( λ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) for an exponential distribution with rate parameter\n `λ`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.exponential.logpdf.factory( 0.5 );\n > var y = mylogpdf( 3.0 )\n ~-2.193\n\n"
+base.dists.exponential.mean,"\nbase.dists.exponential.mean( λ )\n Returns the expected value of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.exponential.mean( 11.0 )\n ~0.091\n > v = base.dists.exponential.mean( 4.5 )\n ~0.222\n\n"
+base.dists.exponential.median,"\nbase.dists.exponential.median( λ )\n Returns the median of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.exponential.median( 11.0 )\n ~0.063\n > v = base.dists.exponential.median( 4.5 )\n ~0.154\n\n"
+base.dists.exponential.mode,"\nbase.dists.exponential.mode( λ )\n Returns the mode of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.exponential.mode( 11.0 )\n 0.0\n > v = base.dists.exponential.mode( 4.5 )\n 0.0\n\n"
+base.dists.exponential.pdf,"\nbase.dists.exponential.pdf( x, λ )\n Evaluates the probability density function (PDF) for an exponential\n distribution with rate parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.exponential.pdf( 0.3, 4.0 )\n ~1.205\n > y = base.dists.exponential.pdf( 2.0, 0.7 )\n ~0.173\n > y = base.dists.exponential.pdf( -1.0, 0.5 )\n 0.0\n > y = base.dists.exponential.pdf( 0, NaN )\n NaN\n > y = base.dists.exponential.pdf( NaN, 2.0 )\n NaN\n\n // Negative rate:\n > y = base.dists.exponential.pdf( 2.0, -1.0 )\n NaN\n\nbase.dists.exponential.pdf.factory( λ )\n Returns a function for evaluating the probability density function (PDF)\n for an exponential distribution with rate parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.exponential.pdf.factory( 0.5 );\n > var y = myPDF( 3.0 )\n ~0.112\n\n"
+base.dists.exponential.quantile,"\nbase.dists.exponential.quantile( p, λ )\n Evaluates the quantile function for an exponential distribution with rate\n parameter `λ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.exponential.quantile( 0.8, 1.0 )\n ~1.609\n > y = base.dists.exponential.quantile( 0.5, 4.0 )\n ~0.173\n > y = base.dists.exponential.quantile( 0.5, 0.1 )\n ~6.931\n\n > y = base.dists.exponential.quantile( -0.2, 0.1 )\n NaN\n\n > y = base.dists.exponential.quantile( NaN, 1.0 )\n NaN\n > y = base.dists.exponential.quantile( 0.0, NaN )\n NaN\n\n // Negative rate parameter:\n > y = base.dists.exponential.quantile( 0.5, -1.0 )\n NaN\n\n\nbase.dists.exponential.quantile.factory( λ )\n Returns a function for evaluating the quantile function for an exponential\n distribution with rate parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.exponential.quantile.factory( 0.4 );\n > var y = myQuantile( 0.4 )\n ~1.277\n > y = myQuantile( 1.0 )\n Infinity\n\n"
+base.dists.exponential.skewness,"\nbase.dists.exponential.skewness( λ )\n Returns the skewness of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.exponential.skewness( 11.0 )\n 2.0\n > v = base.dists.exponential.skewness( 4.5 )\n 2.0\n\n"
+base.dists.exponential.stdev,"\nbase.dists.exponential.stdev( λ )\n Returns the standard deviation of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.exponential.stdev( 9.0 )\n ~0.11\n > v = base.dists.exponential.stdev( 1.0 )\n 1.0\n\n"
+base.dists.exponential.variance,"\nbase.dists.exponential.variance( λ )\n Returns the variance of an exponential distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.exponential.variance( 9.0 )\n ~0.012\n > v = base.dists.exponential.variance( 1.0 )\n 1.0\n\n"
+base.dists.f.cdf,"\nbase.dists.f.cdf( x, d1, d2 )\n Evaluates the cumulative distribution function (CDF) for a F distribution\n with numerator degrees of freedom `d1` and denominator degrees of freedom\n `d2` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `d1 <= 0` or `d2 <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.f.cdf( 2.0, 1.0, 1.0 )\n ~0.608\n > var y = base.dists.f.cdf( 2.0, 8.0, 4.0 )\n ~0.737\n > var y = base.dists.f.cdf( -1.0, 2.0, 2.0 )\n 0.0\n > var y = base.dists.f.cdf( PINF, 4.0, 2.0 )\n 1.0\n > var y = base.dists.f.cdf( NINF, 4.0, 2.0 )\n 0.0\n\n > var y = base.dists.f.cdf( NaN, 1.0, 1.0 )\n NaN\n > var y = base.dists.f.cdf( 0.0, NaN, 1.0 )\n NaN\n > var y = base.dists.f.cdf( 0.0, 1.0, NaN )\n NaN\n\n > var y = base.dists.f.cdf( 2.0, 1.0, -1.0 )\n NaN\n > var y = base.dists.f.cdf( 2.0, -1.0, 1.0 )\n NaN\n\n\nbase.dists.f.cdf.factory( d1, d2 )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a F distribution with numerator degrees of freedom `d1` and denominator\n degrees of freedom `d2`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.f.cdf.factory( 10.0, 2.0 );\n > var y = myCDF( 10.0 )\n ~0.906\n > y = myCDF( 8.0 )\n ~0.884\n\n"
+base.dists.f.entropy,"\nbase.dists.f.entropy( d1, d2 )\n Returns the differential entropy of a F distribution (in nats).\n\n If `d1 <= 0` or `d2 <= 0`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.f.entropy( 3.0, 7.0 )\n ~1.298\n > v = base.dists.f.entropy( 4.0, 12.0 )\n ~1.12\n > v = base.dists.f.entropy( 8.0, 2.0 )\n ~2.144\n\n"
+base.dists.f.F,"\nbase.dists.f.F( [d1, d2] )\n Returns a F distribution object.\n\n Parameters\n ----------\n d1: number (optional)\n Numerator degrees of freedom. Must be greater than `0`. Default: `1.0`.\n\n d2: number (optional)\n Denominator degrees of freedom. Must be greater than `0`.\n Default: `1.0`.\n\n Returns\n -------\n f: Object\n Distribution instance.\n\n f.d1: number\n Numerator degrees of freedom. If set, the value must be greater than\n `0`.\n\n f.d2: number\n Denominator degrees of freedom. If set, the value must be greater than\n `0`.\n\n f.entropy: number\n Read-only property which returns the differential entropy.\n\n f.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n f.mean: number\n Read-only property which returns the expected value.\n\n f.mode: number\n Read-only property which returns the mode.\n\n f.skewness: number\n Read-only property which returns the skewness.\n\n f.stdev: number\n Read-only property which returns the standard deviation.\n\n f.variance: number\n Read-only property which returns the variance.\n\n f.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n f.pdf: Function\n Evaluates the probability density function (PDF).\n\n f.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var f = base.dists.f.F( 6.0, 9.0 );\n > f.d1\n 6.0\n > f.d2\n 9.0\n > f.entropy\n ~1.134\n > f.kurtosis\n ~104.564\n > f.mean\n ~1.286\n > f.mode\n ~0.545\n > f.skewness\n ~4.535\n > f.stdev\n ~1.197\n > f.variance\n ~1.433\n > f.cdf( 3.0 )\n ~0.932\n > f.pdf( 2.5 )\n ~0.095\n > f.quantile( 0.8 )\n ~1.826\n\n"
+base.dists.f.kurtosis,"\nbase.dists.f.kurtosis( d1, d2 )\n Returns the excess kurtosis of a F distribution.\n\n If `d1 <= 0` or `d2 <= 8`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.f.kurtosis( 3.0, 9.0 )\n ~124.667\n > v = base.dists.f.kurtosis( 4.0, 12.0 )\n ~26.143\n > v = base.dists.f.kurtosis( 8.0, 9.0 )\n ~100.167\n\n"
+base.dists.f.mean,"\nbase.dists.f.mean( d1, d2 )\n Returns the expected value of a F distribution.\n\n If `d1 <= 0` or `d2 <= 2`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.f.mean( 3.0, 5.0 )\n ~1.667\n > v = base.dists.f.mean( 4.0, 12.0 )\n ~1.2\n > v = base.dists.f.mean( 8.0, 4.0 )\n 2.0\n\n"
+base.dists.f.mode,"\nbase.dists.f.mode( d1, d2 )\n Returns the mode of a F distribution.\n\n If `d1 <= 2` or `d2 <= 0`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.f.mode( 3.0, 5.0 )\n ~0.238\n > v = base.dists.f.mode( 4.0, 12.0 )\n ~0.429\n > v = base.dists.f.mode( 8.0, 4.0 )\n 0.5\n\n"
+base.dists.f.pdf,"\nbase.dists.f.pdf( x, d1, d2 )\n Evaluates the probability density function (PDF) for a F distribution with\n numerator degrees of freedom `d1` and denominator degrees of freedom `d2` at\n a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `d1 <= 0` or `d2 <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.f.pdf( 2.0, 0.5, 1.0 )\n ~0.057\n > y = base.dists.f.pdf( 0.1, 1.0, 1.0 )\n ~0.915\n > y = base.dists.f.pdf( -1.0, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.f.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.f.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.f.pdf( 0.0, 1.0, NaN )\n NaN\n\n > y = base.dists.f.pdf( 2.0, 1.0, -1.0 )\n NaN\n > y = base.dists.f.pdf( 2.0, -1.0, 1.0 )\n NaN\n\n\nbase.dists.f.pdf.factory( d1, d2 )\n Returns a function for evaluating the probability density function (PDF) of\n a F distribution with numerator degrees of freedom `d1` and denominator\n degrees of freedom `d2`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.f.pdf.factory( 6.0, 7.0 );\n > var y = myPDF( 7.0 )\n ~0.004\n > y = myPDF( 2.0 )\n ~0.166\n\n"
+base.dists.f.quantile,"\nbase.dists.f.quantile( p, d1, d2 )\n Evaluates the quantile function for a F distribution with numerator degrees\n of freedom `d1` and denominator degrees of freedom `d2` at a probability\n `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `d1 <= 0` or `d2 <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.f.quantile( 0.8, 1.0, 1.0 )\n ~9.472\n > y = base.dists.f.quantile( 0.5, 4.0, 2.0 )\n ~1.207\n\n > y = base.dists.f.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.f.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.f.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.f.quantile( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.f.quantile( 0.5, 1.0, NaN )\n NaN\n\n > y = base.dists.f.quantile( 0.5, -1.0, 1.0 )\n NaN\n > y = base.dists.f.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.f.quantile.factory( d1, d2 )\n Returns a function for evaluating the quantile function of a F distribution\n with numerator degrees of freedom `d1` and denominator degrees of freedom\n `d2`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.f.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.2 )\n ~0.527\n > y = myQuantile( 0.8 )\n ~4.382\n\n"
+base.dists.f.skewness,"\nbase.dists.f.skewness( d1, d2 )\n Returns the skewness of a F distribution.\n\n If `d1 <= 0` or `d2 <= 6`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.f.skewness( 3.0, 7.0 )\n 11.0\n > v = base.dists.f.skewness( 4.0, 12.0 )\n ~3.207\n > v = base.dists.f.skewness( 8.0, 7.0 )\n ~10.088\n\n"
+base.dists.f.stdev,"\nbase.dists.f.stdev( d1, d2 )\n Returns the standard deviation of a F distribution.\n\n If `d1 <= 0` or `d2 <= 4`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.f.stdev( 3.0, 5.0 )\n ~3.333\n > v = base.dists.f.stdev( 4.0, 12.0 )\n ~1.122\n > v = base.dists.f.stdev( 8.0, 5.0 )\n ~2.764\n\n"
+base.dists.f.variance,"\nbase.dists.f.variance( d1, d2 )\n Returns the variance of a F distribution.\n\n If `d1 <= 0` or `d2 <= 4`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Numerator degrees of freedom.\n\n d2: number\n Denominator degrees of freedom.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.f.variance( 3.0, 5.0 )\n ~11.111\n > v = base.dists.f.variance( 4.0, 12.0 )\n ~1.26\n > v = base.dists.f.variance( 8.0, 5.0 )\n ~7.639\n\n"
+base.dists.frechet.cdf,"\nbase.dists.frechet.cdf( x, α, s, m )\n Evaluates the cumulative distribution function (CDF) for a Fréchet\n distribution with shape parameter `α`, scale parameter `s`, and location\n `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.frechet.cdf( 10.0, 2.0, 3.0, 0.0 )\n ~0.914\n > y = base.dists.frechet.cdf( -1.0, 2.0, 3.0, -3.0 )\n ~0.105\n > y = base.dists.frechet.cdf( 2.5, 2.0, 1.0, 2.0 )\n ~0.018\n > y = base.dists.frechet.cdf( NaN, 1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.cdf( 0.0, NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.cdf( 0.0, 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.cdf( 0.0, 1.0, 1.0, NaN )\n NaN\n > y = base.dists.frechet.cdf( 0.0, -1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.cdf( 0.0, 1.0, -1.0, 0.0 )\n NaN\n\n\nbase.dists.frechet.cdf.factory( α, s, m )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n location `m`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.frechet.cdf.factory( 3.0, 3.0, 5.0 );\n > var y = myCDF( 10.0 )\n ~0.806\n > y = myCDF( 7.0 )\n ~0.034\n\n"
+base.dists.frechet.entropy,"\nbase.dists.frechet.entropy( α, s, m )\n Returns the differential entropy of a Fréchet distribution with shape\n parameter `α`, scale parameter `s`, and location `m` (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.frechet.entropy( 1.0, 1.0, 1.0 )\n ~2.154\n > y = base.dists.frechet.entropy( 4.0, 2.0, 1.0 )\n ~1.028\n > y = base.dists.frechet.entropy( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.entropy( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.entropy( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.Frechet,"\nbase.dists.frechet.Frechet( [α, s, m] )\n Returns a Fréchet distribution object.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter. Must be greater than `0`. Default: `1.0`.\n\n s: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n m: number (optional)\n Location parameter. Default: `0.0`.\n\n Returns\n -------\n frechet: Object\n Distribution instance.\n\n frechet.alpha: number\n Shape parameter. If set, the value must be greater than `0`.\n\n frechet.s: number\n Scale parameter. If set, the value must be greater than `0`.\n\n frechet.m: number\n Location parameter.\n\n frechet.entropy: number\n Read-only property which returns the differential entropy.\n\n frechet.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n frechet.mean: number\n Read-only property which returns the expected value.\n\n frechet.median: number\n Read-only property which returns the median.\n\n frechet.mode: number\n Read-only property which returns the mode.\n\n frechet.skewness: number\n Read-only property which returns the skewness.\n\n frechet.stdev: number\n Read-only property which returns the standard deviation.\n\n frechet.variance: number\n Read-only property which returns the variance.\n\n frechet.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n frechet.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n frechet.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n frechet.pdf: Function\n Evaluates the probability density function (PDF).\n\n frechet.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var frechet = base.dists.frechet.Frechet( 1.0, 1.0, 0.0 );\n > frechet.alpha\n 1.0\n > frechet.s\n 1.0\n > frechet.m\n 0.0\n > frechet.entropy\n ~2.154\n > frechet.kurtosis\n Infinity\n > frechet.mean\n Infinity\n > frechet.median\n ~1.443\n > frechet.mode\n 0.5\n > frechet.skewness\n Infinity\n > frechet.stdev\n Infinity\n > frechet.variance\n Infinity\n > frechet.cdf( 0.8 )\n ~0.287\n > frechet.logcdf( 0.8 )\n -1.25\n > frechet.logpdf( 0.8 )\n ~-0.804\n > frechet.pdf( 0.8 )\n ~0.448\n > frechet.quantile( 0.8 )\n ~4.481\n\n"
+base.dists.frechet.kurtosis,"\nbase.dists.frechet.kurtosis( α, s, m )\n Returns the excess kurtosis of a Fréchet distribution with shape parameter\n `α`, scale parameter `s`, and location `m`.\n\n If provided `0 < α <= 4` and `s > 0`, the function returns positive\n infinity.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.frechet.kurtosis( 5.0, 2.0, 1.0 )\n ~45.092\n > var y = base.dists.frechet.kurtosis( 5.0, 10.0, -3.0 )\n ~45.092\n > y = base.dists.frechet.kurtosis( 3.5, 2.0, 1.0 )\n Infinity\n > y = base.dists.frechet.kurtosis( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.kurtosis( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.kurtosis( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.logcdf,"\nbase.dists.frechet.logcdf( x, α, s, m )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a Fréchet distribution with shape parameter `α`, scale parameter\n `s`, and location `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.frechet.logcdf( 10.0, 2.0, 3.0, 0.0 )\n ~-0.09\n > y = base.dists.frechet.logcdf( -1.0, 2.0, 3.0, -3.0 )\n ~-2.25\n > y = base.dists.frechet.logcdf( 2.5, 2.0, 1.0, 2.0 )\n -4.0\n > y = base.dists.frechet.logcdf( NaN, 1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.logcdf( 0.0, NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.logcdf( 0.0, 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.logcdf( 0.0, 1.0, 1.0, NaN )\n NaN\n > y = base.dists.frechet.logcdf( 0.0, -1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.logcdf( 0.0, 1.0, -1.0, 0.0 )\n NaN\n\n\nbase.dists.frechet.logcdf.factory( α, s, m )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a Fréchet distribution with shape parameter\n `α`, scale parameter `s`, and location `m`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.frechet.logcdf.factory( 3.0, 3.0, 5.0 );\n > var y = mylogcdf( 10.0 )\n ~-0.216\n > y = mylogcdf( 7.0 )\n ~-3.375\n\n"
+base.dists.frechet.logpdf,"\nbase.dists.frechet.logpdf( x, α, s, m )\n Evaluates the logarithm of the probability density function (PDF) for a\n Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n location `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.frechet.logpdf( 10.0, 1.0, 3.0, 5.0 )\n ~-2.72\n > y = base.dists.frechet.logpdf( -2.0, 1.0, 3.0, -3.0 )\n ~-1.901\n > y = base.dists.frechet.logpdf( 0.0, 2.0, 1.0, -1.0 )\n ~-0.307\n > y = base.dists.frechet.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.frechet.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.frechet.logpdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.frechet.logpdf( 0.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.frechet.logpdf.factory( α, s, m )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Fréchet distribution with shape parameter `α`, scale\n parameter `s`, and location `m`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.frechet.logpdf.factory( 2.0, 3.0, 1.0 );\n > var y = mylogPDF( 10.0 )\n ~-3.812\n > y = mylogPDF( 2.0 )\n ~-6.11\n\n"
+base.dists.frechet.mean,"\nbase.dists.frechet.mean( α, s, m )\n Returns the expected value of a Fréchet distribution with shape parameter\n `α`, scale parameter `s`, and location `m`.\n\n If provided `0 < α <= 1` and `s > 0`, the function returns positive\n infinity.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Mean.\n\n Examples\n --------\n > var y = base.dists.frechet.mean( 4.0, 2.0, 1.0 )\n ~3.451\n > y = base.dists.frechet.mean( 0.5, 2.0, 1.0 )\n Infinity\n > y = base.dists.frechet.mean( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.mean( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.mean( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.median,"\nbase.dists.frechet.median( α, s, m )\n Returns the median of a Fréchet distribution with shape parameter\n `α`, scale parameter `s`, and location `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.frechet.median( 4.0, 2.0, 1.0 )\n ~3.192\n > var y = base.dists.frechet.median( 4.0, 2.0, -3.0 )\n ~-0.808\n > y = base.dists.frechet.median( 0.5, 2.0, 1.0 )\n ~5.163\n > y = base.dists.frechet.median( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.median( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.median( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.mode,"\nbase.dists.frechet.mode( α, s, m )\n Returns the mode of a Fréchet distribution with shape parameter `α`, scale\n parameter `s`, and location `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.frechet.mode( 4.0, 2.0, 1.0 )\n ~2.891\n > var y = base.dists.frechet.mode( 4.0, 2.0, -3.0 )\n ~-1.109\n > y = base.dists.frechet.mode( 0.5, 2.0, 1.0 )\n ~1.222\n > y = base.dists.frechet.mode( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.mode( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.mode( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.pdf,"\nbase.dists.frechet.pdf( x, α, s, m )\n Evaluates the probability density function (PDF) for a Fréchet distribution\n with shape parameter `α`, scale parameter `s`, and location `m`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.frechet.pdf( 10.0, 0.0, 3.0 )\n ~0.965\n > y = base.dists.frechet.pdf( -2.0, 0.0, 3.0 )\n ~0.143\n > y = base.dists.frechet.pdf( 0.0, 0.0, 1.0 )\n ~0.368\n > y = base.dists.frechet.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.frechet.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.frechet.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.frechet.pdf( 0.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.frechet.pdf.factory( α, s, m )\n Returns a function for evaluating the probability density function (PDF) of\n a Fréchet distribution with shape parameter `α`, scale parameter `s`, and\n location `m`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.frechet.pdf.factory( 2.0, 3.0 );\n > var y = myPDF( 10.0 )\n ~0.933\n > y = myPDF( 2.0 )\n ~0.368\n\n"
+base.dists.frechet.quantile,"\nbase.dists.frechet.quantile( p, α, s, m )\n Evaluates the quantile function for a Fréchet distribution with shape\n parameter `α`, scale parameter `s`, and location `m`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.frechet.quantile( 0.3, 10.0, 2.0, 3.0 )\n ~4.963\n > y = base.dists.frechet.quantile( 0.2, 3.0, 3.0, 3.0 )\n ~5.56\n > y = base.dists.frechet.quantile( 0.9, 1.0, 1.0, -3.0 )\n ~6.491\n > y = base.dists.frechet.quantile( NaN, 1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.quantile( 0.0, NaN, 1.0, 0.0)\n NaN\n > y = base.dists.frechet.quantile( 0.0, 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.quantile( 0.0, 1.0, 1.0, NaN )\n NaN\n > y = base.dists.frechet.quantile( 0.0, -1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.quantile( 0.0, 1.0, -1.0, 0.0 )\n NaN\n\n\nbase.dists.frechet.quantile.factory( α, s, m )\n Returns a function for evaluating the quantile function of a Fréchet\n distribution with shape parameter `α`, scale parameter `s`, and location\n `m`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.frechet.quantile.factory( 2.0, 2.0, 3.0 );\n > var y = myQuantile( 0.5 )\n ~5.402\n > y = myQuantile( 0.2 )\n ~4.576\n\n"
+base.dists.frechet.skewness,"\nbase.dists.frechet.skewness( α, s, m )\n Returns the skewness of a Fréchet distribution with shape parameter `α`,\n scale parameter `s`, and location `m`.\n\n If provided `0 < α <= 3` and `s > 0`, the function returns positive\n infinity.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.frechet.skewness( 4.0, 2.0, 1.0 )\n ~5.605\n > var y = base.dists.frechet.skewness( 4.0, 2.0, -3.0 )\n ~5.605\n > y = base.dists.frechet.skewness( 0.5, 2.0, 1.0 )\n Infinity\n > y = base.dists.frechet.skewness( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.skewness( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.skewness( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.stdev,"\nbase.dists.frechet.stdev( α, s, m )\n Returns the standard deviation of a Fréchet distribution with shape\n parameter `α`, scale parameter `s`, and location `m`.\n\n If provided `0 < α <= 2` and `s > 0`, the function returns positive\n infinity.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.frechet.stdev( 4.0, 2.0, 1.0 )\n ~1.041\n > var y = base.dists.frechet.stdev( 4.0, 2.0, -3.0 )\n ~1.041\n > y = base.dists.frechet.stdev( 0.5, 2.0, 1.0 )\n Infinity\n > y = base.dists.frechet.stdev( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.stdev( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.stdev( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.frechet.variance,"\nbase.dists.frechet.variance( α, s, m )\n Returns the variance of a Fréchet distribution with shape parameter `α`,\n scale parameter `s`, and location `m`.\n\n If provided `0 < α <= 2` and `s > 0`, the function returns positive\n infinity.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.frechet.variance( 4.0, 2.0, 1.0 )\n ~1.083\n > var y = base.dists.frechet.variance( 4.0, 2.0, -3.0 )\n ~1.083\n > y = base.dists.frechet.variance( 0.5, 2.0, 1.0 )\n Infinity\n > y = base.dists.frechet.variance( NaN, 1.0, 0.0 )\n NaN\n > y = base.dists.frechet.variance( 1.0, NaN, 0.0 )\n NaN\n > y = base.dists.frechet.variance( 1.0, 1.0, NaN )\n NaN\n\n"
+base.dists.gamma.cdf,"\nbase.dists.gamma.cdf( x, α, β )\n Evaluates the cumulative distribution function (CDF) for a gamma\n distribution with shape parameter `α` and rate parameter `β` at a value `x`.\n\n If `α < 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.gamma.cdf( 2.0, 1.0, 1.0 )\n ~0.865\n > y = base.dists.gamma.cdf( 2.0, 3.0, 1.0 )\n ~0.323\n > y = base.dists.gamma.cdf( -1.0, 2.0, 2.0 )\n 0.0\n > y = base.dists.gamma.cdf( PINF, 4.0, 2.0 )\n 1.0\n > y = base.dists.gamma.cdf( NINF, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.gamma.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gamma.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gamma.cdf( 0.0, 0.0, NaN )\n NaN\n\n > y = base.dists.gamma.cdf( 2.0, -1.0, 1.0 )\n NaN\n > y = base.dists.gamma.cdf( 2.0, 1.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `0` when `α = 0.0`:\n > y = base.dists.gamma.cdf( 2.0, 0.0, 2.0 )\n 1.0\n > y = base.dists.gamma.cdf( -2.0, 0.0, 2.0 )\n 0.0\n > y = base.dists.gamma.cdf( 0.0, 0.0, 2.0 )\n 0.0\n\n\nbase.dists.gamma.cdf.factory( α, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a gamma distribution with shape parameter `α` and rate parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.gamma.cdf.factory( 2.0, 0.5 );\n > var y = myCDF( 6.0 )\n ~0.801\n > y = myCDF( 2.0 )\n ~0.264\n\n"
+base.dists.gamma.entropy,"\nbase.dists.gamma.entropy( α, β )\n Returns the differential entropy of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.gamma.entropy( 1.0, 1.0 )\n 1.0\n > v = base.dists.gamma.entropy( 4.0, 12.0 )\n ~-0.462\n > v = base.dists.gamma.entropy( 8.0, 2.0 )\n ~1.723\n\n"
+base.dists.gamma.Gamma,"\nbase.dists.gamma.Gamma( [α, β] )\n Returns a gamma distribution object.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter. Must be greater than `0`. Default: `1.0`.\n\n β: number (optional)\n Rate parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n gamma: Object\n Distribution instance.\n\n gamma.alpha: number\n Shape parameter. If set, the value must be greater than `0`.\n\n gamma.beta: number\n Rate parameter. If set, the value must be greater than `0`.\n\n gamma.entropy: number\n Read-only property which returns the differential entropy.\n\n gamma.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n gamma.mean: number\n Read-only property which returns the expected value.\n\n gamma.mode: number\n Read-only property which returns the mode.\n\n gamma.skewness: number\n Read-only property which returns the skewness.\n\n gamma.stdev: number\n Read-only property which returns the standard deviation.\n\n gamma.variance: number\n Read-only property which returns the variance.\n\n gamma.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n gamma.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n gamma.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n gamma.pdf: Function\n Evaluates the probability density function (PDF).\n\n gamma.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var gamma = base.dists.gamma.Gamma( 6.0, 5.0 );\n > gamma.alpha\n 6.0\n > gamma.beta\n 5.0\n > gamma.entropy\n ~0.647\n > gamma.kurtosis\n 1.0\n > gamma.mean\n 1.2\n > gamma.mode\n 1.0\n > gamma.skewness\n ~0.816\n > gamma.stdev\n ~0.49\n > gamma.variance\n 0.24\n > gamma.cdf( 0.8 )\n ~0.215\n > gamma.logpdf( 1.0 )\n ~-0.131\n > gamma.mgf( -0.5 )\n ~0.564\n > gamma.pdf( 1.0 )\n ~0.877\n > gamma.quantile( 0.8 )\n ~1.581\n\n"
+base.dists.gamma.kurtosis,"\nbase.dists.gamma.kurtosis( α, β )\n Returns the excess kurtosis of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.gamma.kurtosis( 1.0, 1.0 )\n 6.0\n > v = base.dists.gamma.kurtosis( 4.0, 12.0 )\n 1.5\n > v = base.dists.gamma.kurtosis( 8.0, 2.0 )\n 0.75\n\n"
+base.dists.gamma.logpdf,"\nbase.dists.gamma.logpdf( x, α, β )\n Evaluates the logarithm of the probability density function (PDF) for a\n gamma distribution with shape parameter `α` and rate parameter `β` at a\n value `x`.\n\n If `α < 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.gamma.logpdf( 2.0, 0.5, 1.0 )\n ~-2.919\n > y = base.dists.gamma.logpdf( 0.1, 1.0, 1.0 )\n ~-0.1\n > y = base.dists.gamma.logpdf( -1.0, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.gamma.logpdf( NaN, 0.6, 1.0 )\n NaN\n > y = base.dists.gamma.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gamma.logpdf( 0.0, 1.0, NaN )\n NaN\n\n // Negative shape parameter:\n > y = base.dists.gamma.logpdf( 2.0, -1.0, 1.0 )\n NaN\n // Non-positive rate parameter:\n > y = base.dists.gamma.logpdf( 2.0, 1.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `0.0` when `α = 0.0`:\n > y = base.dists.gamma.logpdf( 2.0, 0.0, 2.0 )\n -Infinity\n > y = base.dists.gamma.logpdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.gamma.logpdf.factory( α, β )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a gamma distribution with shape parameter `α` and rate\n parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.gamma.logpdf.factory( 6.0, 7.0 );\n > var y = mylogPDF( 2.0 )\n ~-3.646\n\n"
+base.dists.gamma.mean,"\nbase.dists.gamma.mean( α, β )\n Returns the expected value of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.gamma.mean( 1.0, 1.0 )\n 1.0\n > v = base.dists.gamma.mean( 4.0, 12.0 )\n ~0.333\n > v = base.dists.gamma.mean( 8.0, 2.0 )\n 4.0\n\n"
+base.dists.gamma.mgf,"\nbase.dists.gamma.mgf( t, α, β )\n Evaluates the moment-generating function (MGF) for a gamma distribution with\n shape parameter `α` and rate parameter `β` at a value `t`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.gamma.mgf( 0.5, 0.5, 1.0 )\n ~1.414\n > y = base.dists.gamma.mgf( 0.1, 1.0, 1.0 )\n ~1.111\n > y = base.dists.gamma.mgf( -1.0, 4.0, 2.0 )\n ~0.198\n\n > y = base.dists.gamma.mgf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.gamma.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gamma.mgf( 0.0, 1.0, NaN )\n NaN\n\n > y = base.dists.gamma.mgf( 2.0, 4.0, 1.0 )\n NaN\n > y = base.dists.gamma.mgf( 2.0, -0.5, 1.0 )\n NaN\n > y = base.dists.gamma.mgf( 2.0, 1.0, 0.0 )\n NaN\n > y = base.dists.gamma.mgf( 2.0, 1.0, -1.0 )\n NaN\n\n\nbase.dists.gamma.mgf.factory( α, β )\n Returns a function for evaluating the moment-generating function (MGF) of a\n gamma distribution with shape parameter `α` and rate parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.gamma.mgf.factory( 3.0, 1.5 );\n > var y = myMGF( 1.0 )\n ~27.0\n > y = myMGF( 0.5 )\n ~3.375\n\n"
+base.dists.gamma.mode,"\nbase.dists.gamma.mode( α, β )\n Returns the mode of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.gamma.mode( 1.0, 1.0 )\n 0.0\n > v = base.dists.gamma.mode( 4.0, 12.0 )\n 0.25\n > v = base.dists.gamma.mode( 8.0, 2.0 )\n 3.5\n\n"
+base.dists.gamma.pdf,"\nbase.dists.gamma.pdf( x, α, β )\n Evaluates the probability density function (PDF) for a gamma distribution\n with shape parameter `α` and rate parameter `β` at a value `x`.\n\n If `α < 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.gamma.pdf( 2.0, 0.5, 1.0 )\n ~0.054\n > y = base.dists.gamma.pdf( 0.1, 1.0, 1.0 )\n ~0.905\n > y = base.dists.gamma.pdf( -1.0, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.gamma.pdf( NaN, 0.6, 1.0 )\n NaN\n > y = base.dists.gamma.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gamma.pdf( 0.0, 1.0, NaN )\n NaN\n\n // Negative shape parameter:\n > y = base.dists.gamma.pdf( 2.0, -1.0, 1.0 )\n NaN\n // Non-positive rate parameter:\n > y = base.dists.gamma.pdf( 2.0, 1.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `0.0` when `α = 0.0`:\n > y = base.dists.gamma.pdf( 2.0, 0.0, 2.0 )\n 0.0\n > y = base.dists.gamma.pdf( 0.0, 0.0, 2.0 )\n Infinity\n\n\nbase.dists.gamma.pdf.factory( α, β )\n Returns a function for evaluating the probability density function (PDF) of\n a gamma distribution with shape parameter `α` and rate parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.gamma.pdf.factory( 6.0, 7.0 );\n > var y = myPDF( 2.0 )\n ~0.026\n\n"
+base.dists.gamma.quantile,"\nbase.dists.gamma.quantile( p, α, β )\n Evaluates the quantile function for a gamma distribution with shape\n parameter `α` and rate parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If `α < 0` or `β <= 0`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.gamma.quantile( 0.8, 2.0, 1.0 )\n ~2.994\n > y = base.dists.gamma.quantile( 0.5, 4.0, 2.0 )\n ~1.836\n\n > y = base.dists.gamma.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.gamma.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.gamma.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.gamma.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gamma.quantile( 0.0, 1.0, NaN )\n NaN\n\n // Non-positive shape parameter:\n > y = base.dists.gamma.quantile( 0.5, -1.0, 1.0 )\n NaN\n // Non-positive rate parameter:\n > y = base.dists.gamma.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `0.0` when `α = 0.0`:\n > y = base.dists.gamma.quantile( 0.3, 0.0, 2.0 )\n 0.0\n > y = base.dists.gamma.quantile( 0.9, 0.0, 2.0 )\n 0.0\n\n\nbase.dists.gamma.quantile.factory( α, β )\n Returns a function for evaluating the quantile function of a gamma\n distribution with shape parameter `α` and rate parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.gamma.quantile.factory( 2.0, 2.0 );\n > var y = myQuantile( 0.8 )\n ~1.497\n > y = myQuantile( 0.4 )\n ~0.688\n\n"
+base.dists.gamma.skewness,"\nbase.dists.gamma.skewness( α, β )\n Returns the skewness of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.gamma.skewness( 1.0, 1.0 )\n 2.0\n > v = base.dists.gamma.skewness( 4.0, 12.0 )\n 1.0\n > v = base.dists.gamma.skewness( 8.0, 2.0 )\n ~0.707\n\n"
+base.dists.gamma.stdev,"\nbase.dists.gamma.stdev( α, β )\n Returns the standard deviation of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.gamma.stdev( 1.0, 1.0 )\n 1.0\n > v = base.dists.gamma.stdev( 4.0, 12.0 )\n ~0.167\n > v = base.dists.gamma.stdev( 8.0, 2.0 )\n ~1.414\n\n"
+base.dists.gamma.variance,"\nbase.dists.gamma.variance( α, β )\n Returns the variance of a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.gamma.variance( 1.0, 1.0 )\n 1.0\n > v = base.dists.gamma.variance( 4.0, 12.0 )\n ~0.028\n > v = base.dists.gamma.variance( 8.0, 2.0 )\n 2.0\n\n"
+base.dists.geometric.cdf,"\nbase.dists.geometric.cdf( x, p )\n Evaluates the cumulative distribution function (CDF) for a geometric\n distribution with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.geometric.cdf( 2.0, 0.5 )\n 0.875\n > y = base.dists.geometric.cdf( 2.0, 0.1 )\n ~0.271\n > y = base.dists.geometric.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.geometric.cdf( NaN, 0.5 )\n NaN\n > y = base.dists.geometric.cdf( 0.0, NaN )\n NaN\n // Invalid probability\n > y = base.dists.geometric.cdf( 2.0, 1.4 )\n NaN\n\n\nbase.dists.geometric.cdf.factory( p )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a geometric distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.geometric.cdf.factory( 0.5 );\n > var y = mycdf( 3.0 )\n 0.9375\n > y = mycdf( 1.0 )\n 0.75\n\n"
+base.dists.geometric.entropy,"\nbase.dists.geometric.entropy( p )\n Returns the entropy of a geometric distribution with success probability\n `p` (in nats).\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.geometric.entropy( 0.1 )\n ~3.251\n > v = base.dists.geometric.entropy( 0.5 )\n ~1.386\n\n"
+base.dists.geometric.Geometric,"\nbase.dists.geometric.Geometric( [p] )\n Returns a geometric distribution object.\n\n Parameters\n ----------\n p: number (optional)\n Success probability. Must be between `0` and `1`. Default: `0.5`.\n\n Returns\n -------\n geometric: Object\n Distribution instance.\n\n geometric.p: number\n Success probability. If set, the value must be between `0` and `1`.\n\n geometric.entropy: number\n Read-only property which returns the differential entropy.\n\n geometric.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n geometric.mean: number\n Read-only property which returns the expected value.\n\n geometric.median: number\n Read-only property which returns the median.\n\n geometric.mode: number\n Read-only property which returns the mode.\n\n geometric.skewness: number\n Read-only property which returns the skewness.\n\n geometric.stdev: number\n Read-only property which returns the standard deviation.\n\n geometric.variance: number\n Read-only property which returns the variance.\n\n geometric.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n geometric.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n geometric.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n geometric.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n geometric.pmf: Function\n Evaluates the probability mass function (PMF).\n\n geometric.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var geometric = base.dists.geometric.Geometric( 0.6 );\n > geometric.p\n 0.6\n > geometric.entropy\n ~1.122\n > geometric.kurtosis\n ~6.9\n > geometric.mean\n ~0.667\n > geometric.median\n 0.0\n > geometric.mode\n 0.0\n > geometric.skewness\n ~2.214\n > geometric.stdev\n ~1.054\n > geometric.variance\n ~1.111\n > geometric.cdf( 3.0 )\n ~0.974\n > geometric.logcdf( 3.0 )\n ~-0.026\n > geometric.logpmf( 4.0 )\n ~-4.176\n > geometric.mgf( 0.5 )\n ~2.905\n > geometric.pmf( 2.0 )\n ~0.096\n > geometric.quantile( 0.7 )\n 1.0\n\n"
+base.dists.geometric.kurtosis,"\nbase.dists.geometric.kurtosis( p )\n Returns the excess kurtosis of a geometric distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.geometric.kurtosis( 0.1 )\n ~6.011\n > v = base.dists.geometric.kurtosis( 0.5 )\n 6.5\n\n"
+base.dists.geometric.logcdf,"\nbase.dists.geometric.logcdf( x, p )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n geometric distribution with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.geometric.logcdf( 2.0, 0.5 )\n ~-0.134\n > y = base.dists.geometric.logcdf( 2.0, 0.1 )\n ~-1.306\n > y = base.dists.geometric.logcdf( -1.0, 4.0 )\n -Infinity\n > y = base.dists.geometric.logcdf( NaN, 0.5 )\n NaN\n > y = base.dists.geometric.logcdf( 0.0, NaN )\n NaN\n // Invalid probability\n > y = base.dists.geometric.logcdf( 2.0, 1.4 )\n NaN\n\n\nbase.dists.geometric.logcdf.factory( p )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a geometric distribution with success\n probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.geometric.logcdf.factory( 0.5 );\n > var y = mylogcdf( 3.0 )\n ~-0.065\n > y = mylogcdf( 1.0 )\n ~-0.288\n\n"
+base.dists.geometric.logpmf,"\nbase.dists.geometric.logpmf( x, p )\n Evaluates the logarithm of the probability mass function (PMF) for a\n geometric distribution with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.geometric.logpmf( 4.0, 0.3 )\n ~-2.631\n > y = base.dists.geometric.logpmf( 2.0, 0.7 )\n ~-2.765\n > y = base.dists.geometric.logpmf( -1.0, 0.5 )\n -Infinity\n > y = base.dists.geometric.logpmf( 0.0, NaN )\n NaN\n > y = base.dists.geometric.logpmf( NaN, 0.5 )\n NaN\n // Invalid success probability:\n > y = base.dists.geometric.logpmf( 2.0, 1.5 )\n NaN\n\n\nbase.dists.geometric.logpmf.factory( p )\n Returns a function for evaluating the logarithm of the probability mass\n function (PMF) of a geometric distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogpmf = base.dists.geometric.logpmf.factory( 0.5 );\n > var y = mylogpmf( 3.0 )\n ~-2.773\n > y = mylogpmf( 1.0 )\n ~-1.386\n\n"
+base.dists.geometric.mean,"\nbase.dists.geometric.mean( p )\n Returns the expected value of a geometric distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.geometric.mean( 0.1 )\n 9.0\n > v = base.dists.geometric.mean( 0.5 )\n 1.0\n\n"
+base.dists.geometric.median,"\nbase.dists.geometric.median( p )\n Returns the median of a geometric distribution with success probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: integer\n Median.\n\n Examples\n --------\n > var v = base.dists.geometric.median( 0.1 )\n 6\n > v = base.dists.geometric.median( 0.5 )\n 0\n\n"
+base.dists.geometric.mgf,"\nbase.dists.geometric.mgf( t, p )\n Evaluates the moment-generating function (MGF) for a geometric\n distribution with success probability `p` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If `t >= -ln(1-p)`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.geometric.mgf( 0.2, 0.5 )\n ~1.569\n > y = base.dists.geometric.mgf( 0.4, 0.5 )\n ~2.936\n // Case: t >= -ln(1-p)\n > y = base.dists.geometric.mgf( 0.8, 0.5 )\n NaN\n > y = base.dists.geometric.mgf( NaN, 0.0 )\n NaN\n > y = base.dists.geometric.mgf( 0.0, NaN )\n NaN\n > y = base.dists.geometric.mgf( -2.0, -1.0 )\n NaN\n > y = base.dists.geometric.mgf( 0.2, 2.0 )\n NaN\n\n\nbase.dists.geometric.mgf.factory( p )\n Returns a function for evaluating the moment-generating function (MGF) of a\n geometric distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.geometric.mgf.factory( 0.8 );\n > var y = mymgf( -0.2 )\n ~0.783\n\n"
+base.dists.geometric.mode,"\nbase.dists.geometric.mode( p )\n Returns the mode of a geometric distribution with success probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: integer\n Mode.\n\n Examples\n --------\n > var v = base.dists.geometric.mode( 0.1 )\n 0\n > v = base.dists.geometric.mode( 0.5 )\n 0\n\n"
+base.dists.geometric.pmf,"\nbase.dists.geometric.pmf( x, p )\n Evaluates the probability mass function (PMF) for a geometric distribution\n with success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.geometric.pmf( 4.0, 0.3 )\n ~0.072\n > y = base.dists.geometric.pmf( 2.0, 0.7 )\n ~0.063\n > y = base.dists.geometric.pmf( -1.0, 0.5 )\n 0.0\n > y = base.dists.geometric.pmf( 0.0, NaN )\n NaN\n > y = base.dists.geometric.pmf( NaN, 0.5 )\n NaN\n // Invalid success probability:\n > y = base.dists.geometric.pmf( 2.0, 1.5 )\n NaN\n\n\nbase.dists.geometric.pmf.factory( p )\n Returns a function for evaluating the probability mass function (PMF) of a\n geometric distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var mypmf = base.dists.geometric.pmf.factory( 0.5 );\n > var y = mypmf( 3.0 )\n 0.0625\n > y = mypmf( 1.0 )\n 0.25\n\n"
+base.dists.geometric.quantile,"\nbase.dists.geometric.quantile( r, p )\n Evaluates the quantile function for a geometric distribution with success\n probability `p` at a probability `r`.\n\n If `r < 0` or `r > 1`, the function returns `NaN`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n r: number\n Input probability.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.geometric.quantile( 0.8, 0.4 )\n 3\n > y = base.dists.geometric.quantile( 0.5, 0.4 )\n 1\n > y = base.dists.geometric.quantile( 0.9, 0.1 )\n 21\n\n > y = base.dists.geometric.quantile( -0.2, 0.1 )\n NaN\n\n > y = base.dists.geometric.quantile( NaN, 0.8 )\n NaN\n > y = base.dists.geometric.quantile( 0.4, NaN )\n NaN\n\n > y = base.dists.geometric.quantile( 0.5, -1.0 )\n NaN\n > y = base.dists.geometric.quantile( 0.5, 1.5 )\n NaN\n\n\nbase.dists.geometric.quantile.factory( p )\n Returns a function for evaluating the quantile function of a geometric\n distribution with success probability `p`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.geometric.quantile.factory( 0.4 );\n > var y = myquantile( 0.4 )\n 0\n > y = myquantile( 0.8 )\n 3\n > y = myquantile( 1.0 )\n Infinity\n\n"
+base.dists.geometric.skewness,"\nbase.dists.geometric.skewness( p )\n Returns the skewness of a geometric distribution with success probability\n `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.geometric.skewness( 0.1 )\n ~2.003\n > v = base.dists.geometric.skewness( 0.5 )\n ~2.121\n\n"
+base.dists.geometric.stdev,"\nbase.dists.geometric.stdev( p )\n Returns the standard deviation of a geometric distribution with success\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.geometric.stdev( 0.1 )\n ~9.487\n > v = base.dists.geometric.stdev( 0.5 )\n ~1.414\n\n"
+base.dists.geometric.variance,"\nbase.dists.geometric.variance( p )\n Returns the variance of a geometric distribution with success probability\n `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.geometric.variance( 0.1 )\n ~90.0\n > v = base.dists.geometric.variance( 0.5 )\n 2.0\n\n"
+base.dists.gumbel.cdf,"\nbase.dists.gumbel.cdf( x, μ, β )\n Evaluates the cumulative distribution function (CDF) for a Gumbel\n distribution with location parameter `μ` and scale parameter `β` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.gumbel.cdf( 10.0, 0.0, 3.0 )\n ~0.965\n > y = base.dists.gumbel.cdf( -2.0, 0.0, 3.0 )\n ~0.143\n > y = base.dists.gumbel.cdf( 0.0, 0.0, 1.0 )\n ~0.368\n > y = base.dists.gumbel.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.cdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.gumbel.cdf( 0.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.cdf.factory( μ, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Gumbel distribution with location parameter `μ` and scale parameter\n `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.gumbel.cdf.factory( 2.0, 3.0 );\n > var y = myCDF( 10.0 )\n ~0.933\n > y = myCDF( 2.0 )\n ~0.368\n\n"
+base.dists.gumbel.entropy,"\nbase.dists.gumbel.entropy( μ, β )\n Returns the differential entropy of a Gumbel distribution with location\n parameter `μ` and scale parameter `β` (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.gumbel.entropy( 0.0, 1.0 )\n ~1.577\n > y = base.dists.gumbel.entropy( 4.0, 2.0 )\n ~2.27\n > y = base.dists.gumbel.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.entropy( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.Gumbel,"\nbase.dists.gumbel.Gumbel( [μ, β] )\n Returns a Gumbel distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n β: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n gumbel: Object\n Distribution instance.\n\n gumbel.mu: number\n Location parameter.\n\n gumbel.beta: number\n Scale parameter. If set, the value must be greater than `0`.\n\n gumbel.entropy: number\n Read-only property which returns the differential entropy.\n\n gumbel.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n gumbel.mean: number\n Read-only property which returns the expected value.\n\n gumbel.median: number\n Read-only property which returns the median.\n\n gumbel.mode: number\n Read-only property which returns the mode.\n\n gumbel.skewness: number\n Read-only property which returns the skewness.\n\n gumbel.stdev: number\n Read-only property which returns the standard deviation.\n\n gumbel.variance: number\n Read-only property which returns the variance.\n\n gumbel.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n gumbel.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n gumbel.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n gumbel.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n gumbel.pdf: Function\n Evaluates the probability density function (PDF).\n\n gumbel.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var gumbel = base.dists.gumbel.Gumbel( -2.0, 3.0 );\n > gumbel.mu\n -2.0\n > gumbel.beta\n 3.0\n > gumbel.entropy\n ~2.676\n > gumbel.kurtosis\n 2.4\n > gumbel.mean\n ~-0.268\n > gumbel.median\n ~-0.9\n > gumbel.mode\n -2.0\n > gumbel.skewness\n ~1.14\n > gumbel.stdev\n ~3.848\n > gumbel.variance\n ~14.804\n > gumbel.cdf( 0.8 )\n ~0.675\n > gumbel.logcdf( 0.8 )\n ~-0.393\n > gumbel.logpdf( 1.0 )\n ~-2.466\n > gumbel.mgf( 0.2 )\n ~1.487\n > gumbel.pdf( 1.0 )\n ~0.085\n > gumbel.quantile( 0.8 )\n ~2.5\n\n"
+base.dists.gumbel.kurtosis,"\nbase.dists.gumbel.kurtosis( μ, β )\n Returns the excess kurtosis of a Gumbel distribution with location parameter\n `μ` and scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.gumbel.kurtosis( 0.0, 1.0 )\n 2.4\n > y = base.dists.gumbel.kurtosis( 4.0, 2.0 )\n 2.4\n > y = base.dists.gumbel.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.kurtosis( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.logcdf,"\nbase.dists.gumbel.logcdf( x, μ, β )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n Gumbel distribution with location parameter `μ` and scale parameter `β` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.gumbel.logcdf( 10.0, 0.0, 3.0 )\n ~-0.036\n > y = base.dists.gumbel.logcdf( -2.0, 0.0, 3.0 )\n ~-1.948\n > y = base.dists.gumbel.logcdf( 0.0, 0.0, 1.0 )\n ~-1.0\n > y = base.dists.gumbel.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.logcdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.gumbel.logcdf( 0.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.logcdf.factory( μ, β )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Gumbel distribution with location parameter\n `μ` and scale parameter `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var myLCDF = base.dists.gumbel.logcdf.factory( 2.0, 3.0 );\n > var y = myLCDF( 10.0 )\n ~-0.069\n > y = myLCDF( 2.0 )\n ~-1.0\n\n"
+base.dists.gumbel.logpdf,"\nbase.dists.gumbel.logpdf( x, μ, β )\n Evaluates the logarithm of the probability density function (PDF) for a\n Gumbel distribution with location parameter `μ` and scale parameter `β` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.gumbel.logpdf( 0.0, 0.0, 2.0 )\n ~-1.693\n > y = base.dists.gumbel.logpdf( 0.0, 0.0, 1.0 )\n ~-1\n > y = base.dists.gumbel.logpdf( 1.0, 3.0, 2.0 )\n ~-2.411\n > y = base.dists.gumbel.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.logpdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.gumbel.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.logpdf.factory( μ, β )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Gumbel distribution with location parameter `μ` and\n scale parameter `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.gumbel.logpdf.factory( 10.0, 2.0 );\n > var y = mylogpdf( 10.0 )\n ~-1.693\n > y = mylogpdf( 12.0 )\n ~-2.061\n\n"
+base.dists.gumbel.mean,"\nbase.dists.gumbel.mean( μ, β )\n Returns the expected value of a Gumbel distribution with location parameter\n `μ` and scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.gumbel.mean( 0.0, 1.0 )\n ~0.577\n > y = base.dists.gumbel.mean( 4.0, 2.0 )\n ~5.154\n > y = base.dists.gumbel.mean( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.mean( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.median,"\nbase.dists.gumbel.median( μ, β )\n Returns the median of a Gumbel distribution with location parameter `μ` and\n scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.gumbel.median( 0.0, 1.0 )\n ~0.367\n > y = base.dists.gumbel.median( 4.0, 2.0 )\n ~4.733\n > y = base.dists.gumbel.median( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.median( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.mgf,"\nbase.dists.gumbel.mgf( t, μ, β )\n Evaluates the moment-generating function (MGF) for a Gumbel distribution\n with location parameter `μ` and scale parameter `β` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.gumbel.mgf( -1.0, 0.0, 3.0 )\n 6.0\n > y = base.dists.gumbel.mgf( 0.0, 0.0, 1.0 )\n 1.0\n > y = base.dists.gumbel.mgf( 0.1, 0.0, 3.0 )\n ~1.298\n\n > y = base.dists.gumbel.mgf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.mgf( 0.0, 0.0, NaN )\n NaN\n\n // Case: `t >= 1/beta`\n > y = base.dists.gumbel.mgf( 0.8, 0.0, 2.0 )\n NaN\n\n // Non-positive scale parameter:\n > y = base.dists.gumbel.mgf( 0.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.mgf.factory( μ, β )\n Returns a function for evaluating the moment-generating function (MGF) of a\n Gumbel distribution with location parameter `μ` and scale parameter `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.gumbel.mgf.factory( 0.0, 3.0 );\n > var y = myMGF( -1.5 )\n ~52.343\n > y = myMGF( -1.0 )\n 6.0\n\n"
+base.dists.gumbel.mode,"\nbase.dists.gumbel.mode( μ, β )\n Returns the mode of a Gumbel distribution with location parameter `μ` and\n scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.gumbel.mode( 0.0, 1.0 )\n 0.0\n > y = base.dists.gumbel.mode( 4.0, 2.0 )\n 4.0\n > y = base.dists.gumbel.mode( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.mode( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.pdf,"\nbase.dists.gumbel.pdf( x, μ, β )\n Evaluates the probability density function (PDF) for a Gumbel distribution\n with location parameter `μ` and scale parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.gumbel.pdf( 0.0, 0.0, 2.0 )\n ~0.184\n > y = base.dists.gumbel.pdf( 0.0, 0.0, 1.0 )\n ~0.368\n > y = base.dists.gumbel.pdf( 1.0, 3.0, 2.0 )\n ~0.09\n > y = base.dists.gumbel.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.gumbel.pdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.pdf.factory( μ, β )\n Returns a function for evaluating the probability density function (PDF)\n of a Gumbel distribution with location parameter `μ` and scale parameter\n `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.gumbel.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 10.0 )\n ~0.184\n > y = myPDF( 12.0 )\n ~0.127\n\n"
+base.dists.gumbel.quantile,"\nbase.dists.gumbel.quantile( p, μ, β )\n Evaluates the quantile function for a Gumbel distribution with location\n parameter `μ` and scale parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.gumbel.quantile( 0.8, 0.0, 1.0 )\n ~1.5\n > y = base.dists.gumbel.quantile( 0.5, 4.0, 2.0 )\n ~4.733\n > y = base.dists.gumbel.quantile( 0.5, 4.0, 4.0 )\n ~5.466\n\n > y = base.dists.gumbel.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.gumbel.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.gumbel.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.gumbel.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.gumbel.quantile.factory( μ, β )\n Returns a function for evaluating the quantile function of a Gumbel\n distribution with location parameter `μ` and scale parameter `β`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.gumbel.quantile.factory( 8.0, 2.0 );\n > var y = myQuantile( 0.5 )\n ~8.733\n > y = myQuantile( 0.7 )\n ~10.062\n\n"
+base.dists.gumbel.skewness,"\nbase.dists.gumbel.skewness( μ, β )\n Returns the skewness of a Gumbel distribution with location parameter `μ`\n and scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.gumbel.skewness( 0.0, 1.0 )\n ~1.14\n > y = base.dists.gumbel.skewness( 4.0, 2.0 )\n ~1.14\n > y = base.dists.gumbel.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.skewness( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.stdev,"\nbase.dists.gumbel.stdev( μ, β )\n Returns the standard deviation of a Gumbel distribution with location\n parameter `μ` and scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.gumbel.stdev( 0.0, 1.0 )\n ~1.283\n > y = base.dists.gumbel.stdev( 4.0, 2.0 )\n ~2.565\n > y = base.dists.gumbel.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.stdev( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.gumbel.variance,"\nbase.dists.gumbel.variance( μ, β )\n Returns the variance of a Gumbel distribution with location parameter `μ`\n and scale parameter `β`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.gumbel.variance( 0.0, 1.0 )\n ~1.645\n > y = base.dists.gumbel.variance( 4.0, 2.0 )\n ~6.58\n > y = base.dists.gumbel.variance( NaN, 1.0 )\n NaN\n > y = base.dists.gumbel.variance( 0.0, NaN )\n NaN\n > y = base.dists.gumbel.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.hypergeometric.cdf,"\nbase.dists.hypergeometric.cdf( x, N, K, n )\n Evaluates the cumulative distribution function (CDF) for a hypergeometric\n distribution with population size `N`, subpopulation size `K`, and number of\n draws `n` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or subpopulation size `K` exceeds population size\n `N`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.hypergeometric.cdf( 1.0, 8, 4, 2 )\n ~0.786\n > y = base.dists.hypergeometric.cdf( 1.5, 8, 4, 2 )\n ~0.786\n > y = base.dists.hypergeometric.cdf( 2.0, 8, 4, 2 )\n 1.0\n > y = base.dists.hypergeometric.cdf( 0, 8, 4, 2)\n ~0.214\n\n > y = base.dists.hypergeometric.cdf( NaN, 10, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.cdf( 0.0, NaN, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.cdf( 0.0, 10, NaN, 2 )\n NaN\n > y = base.dists.hypergeometric.cdf( 0.0, 10, 5, NaN )\n NaN\n\n > y = base.dists.hypergeometric.cdf( 2.0, 10.5, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.cdf( 2.0, 10, 1.5, 2 )\n NaN\n > y = base.dists.hypergeometric.cdf( 2.0, 10, 5, -2.0 )\n NaN\n > y = base.dists.hypergeometric.cdf( 2.0, 10, 5, 12 )\n NaN\n > y = base.dists.hypergeometric.cdf( 2.0, 8, 3, 9 )\n NaN\n\n\nbase.dists.hypergeometric.cdf.factory( N, K, n )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a hypergeometric distribution with population size `N`, subpopulation\n size `K`, and number of draws `n`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.hypergeometric.cdf.factory( 30, 20, 5 );\n > var y = myCDF( 4.0 )\n ~0.891\n > y = myCDF( 1.0 )\n ~0.031\n\n"
+base.dists.hypergeometric.Hypergeometric,"\nbase.dists.hypergeometric.Hypergeometric( [N, K, n] )\n Returns a hypergeometric distribution object.\n\n Parameters\n ----------\n N: integer (optional)\n Population size. Must be a nonnegative integer larger than or equal to\n `K` and `n`.\n\n K: integer (optional)\n Subpopulation size. Must be a nonnegative integer smaller than or equal\n to `N`.\n\n n: integer (optional)\n Number of draws. Must be a nonnegative integer smaller than or equal to\n `N`.\n\n Returns\n -------\n hypergeometric: Object\n Distribution instance.\n\n hypergeometric.N: number\n Population size. If set, the value must be a nonnegative integer larger\n than or equal to `K` and `n`.\n\n hypergeometric.K: number\n Subpopulation size. If set, the value must be a nonnegative integer\n smaller than or equal to `N`.\n\n hypergeometric.n: number\n Number of draws. If set, the value must be a nonnegative integer\n smaller than or equal to `N`.\n\n hypergeometric.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n hypergeometric.mean: number\n Read-only property which returns the expected value.\n\n hypergeometric.mode: number\n Read-only property which returns the mode.\n\n hypergeometric.skewness: number\n Read-only property which returns the skewness.\n\n hypergeometric.stdev: number\n Read-only property which returns the standard deviation.\n\n hypergeometric.variance: number\n Read-only property which returns the variance.\n\n hypergeometric.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n hypergeometric.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n hypergeometric.pmf: Function\n Evaluates the probability mass function (PMF).\n\n hypergeometric.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var hypergeometric = base.dists.hypergeometric.Hypergeometric( 100, 70, 20 );\n > hypergeometric.N\n 100.0\n > hypergeometric.K\n 70.0\n > hypergeometric.n\n 20.0\n > hypergeometric.kurtosis\n ~-0.063\n > hypergeometric.mean\n 14.0\n > hypergeometric.mode\n 14.0\n > hypergeometric.skewness\n ~-0.133\n > hypergeometric.stdev\n ~1.842\n > hypergeometric.variance\n ~3.394\n > hypergeometric.cdf( 2.9 )\n ~0.0\n > hypergeometric.logpmf( 10 )\n ~-3.806\n > hypergeometric.pmf( 10 )\n ~0.022\n > hypergeometric.quantile( 0.8 )\n 16.0\n\n"
+base.dists.hypergeometric.kurtosis,"\nbase.dists.hypergeometric.kurtosis( N, K, n )\n Returns the excess kurtosis of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or subpopulation size `K` exceed population size\n `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.kurtosis( 16, 11, 4 )\n ~-0.326\n > v = base.dists.hypergeometric.kurtosis( 4, 2, 2 )\n 0.0\n\n > v = base.dists.hypergeometric.kurtosis( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.kurtosis( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.kurtosis( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.kurtosis( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.kurtosis( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.kurtosis( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.kurtosis( 20, 10, NaN )\n NaN\n\n"
+base.dists.hypergeometric.logpmf,"\nbase.dists.hypergeometric.logpmf( x, N, K, n )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n hypergeometric distribution with population size `N`, subpopulation size\n `K`, and number of draws `n` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K`, or draws `n`\n which is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.hypergeometric.logpmf( 1.0, 8, 4, 2 )\n ~-0.56\n > y = base.dists.hypergeometric.logpmf( 2.0, 8, 4, 2 )\n ~-1.54\n > y = base.dists.hypergeometric.logpmf( 0.0, 8, 4, 2 )\n ~-1.54\n > y = base.dists.hypergeometric.logpmf( 1.5, 8, 4, 2 )\n -Infinity\n\n > y = base.dists.hypergeometric.logpmf( NaN, 10, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 0.0, NaN, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 0.0, 10, NaN, 2 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 0.0, 10, 5, NaN )\n NaN\n\n > y = base.dists.hypergeometric.logpmf( 2.0, 10.5, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 2.0, 5, 1.5, 2 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 2.0, 10, 5, -2.0 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 2.0, 10, 5, 12 )\n NaN\n > y = base.dists.hypergeometric.logpmf( 2.0, 8, 3, 9 )\n NaN\n\n\nbase.dists.hypergeometric.logpmf.factory( N, K, n )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a hypergeometric distribution with population size\n `N`, subpopulation size `K`, and number of draws `n`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogPMF = base.dists.hypergeometric.logpmf.factory( 30, 20, 5 );\n > var y = mylogPMF( 4.0 )\n ~-1.079\n > y = mylogPMF( 1.0 )\n ~-3.524\n\n"
+base.dists.hypergeometric.mean,"\nbase.dists.hypergeometric.mean( N, K, n )\n Returns the expected value of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.mean( 16, 11, 4 )\n 2.75\n > v = base.dists.hypergeometric.mean( 2, 1, 1 )\n 0.5\n\n > v = base.dists.hypergeometric.mean( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.mean( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.mean( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.mean( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.mean( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.mean( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.mean( 20, 10, NaN )\n NaN\n\n"
+base.dists.hypergeometric.mode,"\nbase.dists.hypergeometric.mode( N, K, n )\n Returns the mode of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.mode( 16, 11, 4 )\n 3\n > v = base.dists.hypergeometric.mode( 2, 1, 1 )\n 1\n\n > v = base.dists.hypergeometric.mode( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.mode( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.mode( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.mode( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.mode( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.mode( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.mode( 20, 10, NaN )\n NaN\n\n"
+base.dists.hypergeometric.pmf,"\nbase.dists.hypergeometric.pmf( x, N, K, n )\n Evaluates the probability mass function (PMF) for a hypergeometric\n distribution with population size `N`, subpopulation size `K`, and number of\n draws `n` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.hypergeometric.pmf( 1.0, 8, 4, 2 )\n ~0.571\n > y = base.dists.hypergeometric.pmf( 2.0, 8, 4, 2 )\n ~0.214\n > y = base.dists.hypergeometric.pmf( 0.0, 8, 4, 2 )\n ~0.214\n > y = base.dists.hypergeometric.pmf( 1.5, 8, 4, 2 )\n 0.0\n\n > y = base.dists.hypergeometric.pmf( NaN, 10, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.pmf( 0.0, NaN, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.pmf( 0.0, 10, NaN, 2 )\n NaN\n > y = base.dists.hypergeometric.pmf( 0.0, 10, 5, NaN )\n NaN\n\n > y = base.dists.hypergeometric.pmf( 2.0, 10.5, 5, 2 )\n NaN\n > y = base.dists.hypergeometric.pmf( 2.0, 5, 1.5, 2 )\n NaN\n > y = base.dists.hypergeometric.pmf( 2.0, 10, 5, -2.0 )\n NaN\n > y = base.dists.hypergeometric.pmf( 2.0, 10, 5, 12 )\n NaN\n > y = base.dists.hypergeometric.pmf( 2.0, 8, 3, 9 )\n NaN\n\n\nbase.dists.hypergeometric.pmf.factory( N, K, n )\n Returns a function for evaluating the probability mass function (PMF) of a\n hypergeometric distribution with population size `N`, subpopulation size\n `K`, and number of draws `n`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var myPMF = base.dists.hypergeometric.pmf.factory( 30, 20, 5 );\n > var y = myPMF( 4.0 )\n ~0.34\n > y = myPMF( 1.0 )\n ~0.029\n\n"
+base.dists.hypergeometric.quantile,"\nbase.dists.hypergeometric.quantile( p, N, K, n )\n Evaluates the quantile function for a hypergeometric distribution with\n population size `N`, subpopulation size `K`, and number of draws `n` at a\n probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.hypergeometric.quantile( 0.4, 40, 20, 10 )\n 5\n > y = base.dists.hypergeometric.quantile( 0.8, 60, 40, 20 )\n 15\n > y = base.dists.hypergeometric.quantile( 0.5, 100, 10, 10 )\n 1\n > y = base.dists.hypergeometric.quantile( 0.0, 100, 40, 20 )\n 0\n > y = base.dists.hypergeometric.quantile( 1.0, 100, 40, 20 )\n 20\n\n > y = base.dists.hypergeometric.quantile( NaN, 40, 20, 10 )\n NaN\n > y = base.dists.hypergeometric.quantile( 0.2, NaN, 20, 10 )\n NaN\n > y = base.dists.hypergeometric.quantile( 0.2, 40, NaN, 10 )\n NaN\n > y = base.dists.hypergeometric.quantile( 0.2, 40, 20, NaN )\n NaN\n\n\nbase.dists.hypergeometric.quantile.factory( N, K, n )\n Returns a function for evaluating the quantile function of a hypergeometric\n distribution with population size `N`, subpopulation size `K`, and number of\n draws `n`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.hypergeometric.quantile.factory( 100, 20, 10 );\n > var y = myQuantile( 0.2 )\n 1\n > y = myQuantile( 0.9 )\n 4\n\n"
+base.dists.hypergeometric.skewness,"\nbase.dists.hypergeometric.skewness( N, K, n )\n Returns the skewness of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.skewness( 16, 11, 4 )\n ~-0.258\n > v = base.dists.hypergeometric.skewness( 4, 2, 2 )\n 0.0\n\n > v = base.dists.hypergeometric.skewness( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.skewness( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.skewness( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.skewness( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.skewness( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.skewness( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.skewness( 20, 10, NaN )\n NaN\n\n"
+base.dists.hypergeometric.stdev,"\nbase.dists.hypergeometric.stdev( N, K, n )\n Returns the standard deviation of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.stdev( 16, 11, 4 )\n ~0.829\n > v = base.dists.hypergeometric.stdev( 2, 1, 1 )\n 0.5\n\n > v = base.dists.hypergeometric.stdev( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.stdev( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.stdev( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.stdev( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.stdev( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.stdev( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.stdev( 20, 10, NaN )\n NaN\n\n"
+base.dists.hypergeometric.variance,"\nbase.dists.hypergeometric.variance( N, K, n )\n Returns the variance of a hypergeometric distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a population size `N`, subpopulation size `K` or draws `n` which\n is not a nonnegative integer, the function returns `NaN`.\n\n If the number of draws `n` or the subpopulation size `K` exceed population\n size `N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.hypergeometric.variance( 16, 11, 4 )\n ~0.688\n > v = base.dists.hypergeometric.variance( 2, 1, 1 )\n 0.25\n\n > v = base.dists.hypergeometric.variance( 10, 5, 12 )\n NaN\n > v = base.dists.hypergeometric.variance( 10.3, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.variance( 10, 5.5, 4 )\n NaN\n > v = base.dists.hypergeometric.variance( 10, 5, 4.5 )\n NaN\n\n > v = base.dists.hypergeometric.variance( NaN, 10, 4 )\n NaN\n > v = base.dists.hypergeometric.variance( 20, NaN, 4 )\n NaN\n > v = base.dists.hypergeometric.variance( 20, 10, NaN )\n NaN\n\n"
+base.dists.invgamma.cdf,"\nbase.dists.invgamma.cdf( x, α, β )\n Evaluates the cumulative distribution function (CDF) for an inverse gamma\n distribution with shape parameter `α` and scale parameter `β` at a value\n `x`.\n\n If `α <= 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.invgamma.cdf( 2.0, 1.0, 1.0 )\n ~0.607\n > y = base.dists.invgamma.cdf( 2.0, 3.0, 1.0 )\n ~0.986\n > y = base.dists.invgamma.cdf( -1.0, 2.0, 2.0 )\n 0.0\n > y = base.dists.invgamma.cdf( PINF, 4.0, 2.0 )\n 1.0\n > y = base.dists.invgamma.cdf( NINF, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.invgamma.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.invgamma.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.invgamma.cdf( 0.0, 0.0, NaN )\n NaN\n\n > y = base.dists.invgamma.cdf( 2.0, -1.0, 1.0 )\n NaN\n > y = base.dists.invgamma.cdf( 2.0, 1.0, -1.0 )\n NaN\n\n\nbase.dists.invgamma.cdf.factory( α, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of an inverse gamma distribution with shape parameter `α` and scale\n parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.invgamma.cdf.factory( 2.0, 0.5 );\n > var y = myCDF( 0.5 )\n ~0.736\n > y = myCDF( 2.0 )\n ~0.974\n\n"
+base.dists.invgamma.entropy,"\nbase.dists.invgamma.entropy( α, β )\n Returns the differential entropy of an inverse gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.invgamma.entropy( 1.0, 1.0 )\n ~2.154\n > v = base.dists.invgamma.entropy( 4.0, 12.0 )\n ~1.996\n > v = base.dists.invgamma.entropy( 8.0, 2.0 )\n ~-0.922\n\n"
+base.dists.invgamma.InvGamma,"\nbase.dists.invgamma.InvGamma( [α, β] )\n Returns an inverse gamma distribution object.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter. Must be greater than `0`. Default: `1.0`.\n\n β: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n invgamma: Object\n Distribution instance.\n\n invgamma.alpha: number\n Shape parameter. If set, the value must be greater than `0`.\n\n invgamma.beta: number\n Scale parameter. If set, the value must be greater than `0`.\n\n invgamma.entropy: number\n Read-only property which returns the differential entropy.\n\n invgamma.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n invgamma.mean: number\n Read-only property which returns the expected value.\n\n invgamma.mode: number\n Read-only property which returns the mode.\n\n invgamma.skewness: number\n Read-only property which returns the skewness.\n\n invgamma.stdev: number\n Read-only property which returns the standard deviation.\n\n invgamma.variance: number\n Read-only property which returns the variance.\n\n invgamma.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n invgamma.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n invgamma.pdf: Function\n Evaluates the probability density function (PDF).\n\n invgamma.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var invgamma = base.dists.invgamma.InvGamma( 6.0, 5.0 );\n > invgamma.alpha\n 6.0\n > invgamma.beta\n 5.0\n > invgamma.entropy\n ~0.454\n > invgamma.kurtosis\n 19.0\n > invgamma.mean\n 1.0\n > invgamma.mode\n ~0.714\n > invgamma.skewness\n ~2.667\n > invgamma.stdev\n 0.5\n > invgamma.variance\n 0.25\n > invgamma.cdf( 0.8 )\n ~0.406\n > invgamma.pdf( 1.0 )\n ~0.877\n > invgamma.logpdf( 1.0 )\n ~-0.131\n > invgamma.quantile( 0.8 )\n ~1.281\n\n"
+base.dists.invgamma.kurtosis,"\nbase.dists.invgamma.kurtosis( α, β )\n Returns the excess kurtosis of an inverse gamma distribution.\n\n If `α <= 4` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.invgamma.kurtosis( 7.0, 5.0 )\n 12.0\n > v = base.dists.invgamma.kurtosis( 6.0, 12.0 )\n 19.0\n > v = base.dists.invgamma.kurtosis( 8.0, 2.0 )\n ~8.7\n\n"
+base.dists.invgamma.logpdf,"\nbase.dists.invgamma.logpdf( x, α, β )\n Evaluates the natural logarithm of the probability density function (PDF)\n for an inverse gamma distribution with shape parameter `α` and scale\n parameter `β` at a value `x`.\n\n If `α <= 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.invgamma.logpdf( 2.0, 0.5, 1.0 )\n ~-2.112\n > y = base.dists.invgamma.logpdf( 0.2, 1.0, 1.0 )\n ~-1.781\n > y = base.dists.invgamma.logpdf( -1.0, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.invgamma.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.invgamma.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.invgamma.logpdf( 0.0, 1.0, NaN )\n NaN\n\n // Negative shape parameter:\n > y = base.dists.invgamma.logpdf( 2.0, -1.0, 1.0 )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.invgamma.logpdf( 2.0, 1.0, -1.0 )\n NaN\n\n\nbase.dists.invgamma.logpdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) for an inverse gamma distribution with shape\n parameter `α` and scale parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.invgamma.logpdf.factory( 6.0, 7.0 );\n > var y = mylogPDF( 2.0 )\n ~-1.464\n\n"
+base.dists.invgamma.mean,"\nbase.dists.invgamma.mean( α, β )\n Returns the expected value of an inverse gamma distribution.\n\n If `α <= 1` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.invgamma.mean( 4.0, 12.0 )\n 4.0\n > v = base.dists.invgamma.mean( 8.0, 2.0 )\n ~0.286\n\n"
+base.dists.invgamma.mode,"\nbase.dists.invgamma.mode( α, β )\n Returns the mode of an inverse gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.invgamma.mode( 1.0, 1.0 )\n 0.5\n > v = base.dists.invgamma.mode( 4.0, 12.0 )\n 2.4\n > v = base.dists.invgamma.mode( 8.0, 2.0 )\n ~0.222\n\n"
+base.dists.invgamma.pdf,"\nbase.dists.invgamma.pdf( x, α, β )\n Evaluates the probability density function (PDF) for an inverse gamma\n distribution with shape parameter `α` and scale parameter `β` at a value\n `x`.\n\n If `α <= 0` or `β <= 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 Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.invgamma.pdf( 2.0, 0.5, 1.0 )\n ~0.121\n > y = base.dists.invgamma.pdf( 0.2, 1.0, 1.0 )\n ~0.168\n > y = base.dists.invgamma.pdf( -1.0, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.invgamma.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.invgamma.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.invgamma.pdf( 0.0, 1.0, NaN )\n NaN\n\n // Negative shape parameter:\n > y = base.dists.invgamma.pdf( 2.0, -1.0, 1.0 )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.invgamma.pdf( 2.0, 1.0, -1.0 )\n NaN\n\n\nbase.dists.invgamma.pdf.factory( α, β )\n Returns a function for evaluating the probability density function (PDF)\n of an inverse gamma distribution with shape parameter `α` and scale\n parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.invgamma.pdf.factory( 6.0, 7.0 );\n > var y = myPDF( 2.0 )\n ~0.231\n\n"
+base.dists.invgamma.quantile,"\nbase.dists.invgamma.quantile( p, α, β )\n Evaluates the quantile function for an inverse gamma distribution with shape\n parameter `α` and scale parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.invgamma.quantile( 0.8, 2.0, 1.0 )\n ~1.213\n > y = base.dists.invgamma.quantile( 0.5, 4.0, 2.0 )\n ~0.545\n > y = base.dists.invgamma.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.invgamma.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.invgamma.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.invgamma.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.invgamma.quantile( 0.0, 1.0, NaN )\n NaN\n\n // Non-positive shape parameter:\n > y = base.dists.invgamma.quantile( 0.5, -1.0, 1.0 )\n NaN\n\n // Non-positive rate parameter:\n > y = base.dists.invgamma.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.invgamma.quantile.factory( α, β )\n Returns a function for evaluating the quantile function of an inverse gamma\n distribution with shape parameter `α` and scale parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.invgamma.quantile.factory( 2.0, 2.0 );\n > var y = myQuantile( 0.8 )\n ~2.426\n > y = myQuantile( 0.4 )\n ~0.989\n\n"
+base.dists.invgamma.skewness,"\nbase.dists.invgamma.skewness( α, β )\n Returns the skewness of an inverse gamma distribution.\n\n If `α <= 3` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.invgamma.skewness( 4.0, 12.0 )\n ~5.657\n > v = base.dists.invgamma.skewness( 8.0, 2.0 )\n ~1.96\n\n"
+base.dists.invgamma.stdev,"\nbase.dists.invgamma.stdev( α, β )\n Returns the standard deviation of an inverse gamma distribution.\n\n If `α <= 2` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.invgamma.stdev( 5.0, 7.0 )\n ~1.01\n > v = base.dists.invgamma.stdev( 4.0, 12.0 )\n ~2.828\n > v = base.dists.invgamma.stdev( 8.0, 2.0 )\n ~0.117\n\n"
+base.dists.invgamma.variance,"\nbase.dists.invgamma.variance( α, β )\n Returns the variance of an inverse gamma distribution.\n\n If `α <= 2` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.invgamma.variance( 5.0, 7.0 )\n ~1.021\n > v = base.dists.invgamma.variance( 4.0, 12.0 )\n 8.0\n > v = base.dists.invgamma.variance( 8.0, 2.0 )\n ~0.014\n\n"
+base.dists.kumaraswamy.cdf,"\nbase.dists.kumaraswamy.cdf( x, a, b )\n Evaluates the cumulative distribution function (CDF) for Kumaraswamy's\n double bounded distribution with first shape parameter `a` and second shape\n parameter `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.kumaraswamy.cdf( 0.5, 1.0, 1.0 )\n ~0.5\n > y = base.dists.kumaraswamy.cdf( 0.5, 2.0, 4.0 )\n ~0.684\n > y = base.dists.kumaraswamy.cdf( 0.2, 2.0, 2.0 )\n ~0.078\n > y = base.dists.kumaraswamy.cdf( 0.8, 4.0, 4.0 )\n ~0.878\n > y = base.dists.kumaraswamy.cdf( -0.5, 4.0, 2.0 )\n 0.0\n > y = base.dists.kumaraswamy.cdf( 1.5, 4.0, 2.0 )\n 1.0\n\n > y = base.dists.kumaraswamy.cdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.kumaraswamy.cdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.kumaraswamy.cdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.cdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.kumaraswamy.cdf.factory( a, b )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Kumaraswamy's double bounded distribution with first shape parameter\n `a` and second shape parameter `b`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.kumaraswamy.cdf.factory( 0.5, 1.0 );\n > var y = mycdf( 0.8 )\n ~0.894\n > y = mycdf( 0.3 )\n ~0.548\n\n"
+base.dists.kumaraswamy.Kumaraswamy,"\nbase.dists.kumaraswamy.Kumaraswamy( [a, b] )\n Returns a Kumaraswamy's double bounded distribution object.\n\n Parameters\n ----------\n a: number (optional)\n First shape parameter. Must be greater than `0`. Default: `1.0`.\n\n b: number (optional)\n Second shape parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n kumaraswamy: Object\n Distribution instance.\n\n kumaraswamy.a: number\n First shape parameter. If set, the value must be greater than `0`.\n\n kumaraswamy.b: number\n Second shape parameter. If set, the value must be greater than `0`.\n\n kumaraswamy.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n kumaraswamy.mean: number\n Read-only property which returns the expected value.\n\n kumaraswamy.mode: number\n Read-only property which returns the mode.\n\n kumaraswamy.skewness: number\n Read-only property which returns the skewness.\n\n kumaraswamy.stdev: number\n Read-only property which returns the standard deviation.\n\n kumaraswamy.variance: number\n Read-only property which returns the variance.\n\n kumaraswamy.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n kumaraswamy.pdf: Function\n Evaluates the probability density function (PDF).\n\n kumaraswamy.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var kumaraswamy = base.dists.kumaraswamy.Kumaraswamy( 6.0, 5.0 );\n > kumaraswamy.a\n 6.0\n > kumaraswamy.b\n 5.0\n > kumaraswamy.kurtosis\n ~3.194\n > kumaraswamy.mean\n ~0.696\n > kumaraswamy.mode\n ~0.746\n > kumaraswamy.skewness\n ~-0.605\n > kumaraswamy.stdev\n ~0.126\n > kumaraswamy.variance\n ~0.016\n > kumaraswamy.cdf( 0.8 )\n ~0.781\n > kumaraswamy.pdf( 1.0 )\n ~0.0\n > kumaraswamy.quantile( 0.8 )\n ~0.807\n\n"
+base.dists.kumaraswamy.kurtosis,"\nbase.dists.kumaraswamy.kurtosis( a, b )\n Returns the excess kurtosis of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.kurtosis( 1.0, 1.0 )\n ~1.8\n > v = base.dists.kumaraswamy.kurtosis( 4.0, 12.0 )\n ~2.704\n > v = base.dists.kumaraswamy.kurtosis( 16.0, 8.0 )\n ~4.311\n\n"
+base.dists.kumaraswamy.logcdf,"\nbase.dists.kumaraswamy.logcdf( x, a, b )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for Kumaraswamy's double bounded distribution with first shape\n parameter `a` and second shape parameter `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.kumaraswamy.logcdf( 0.5, 1.0, 1.0 )\n ~-0.693\n > y = base.dists.kumaraswamy.logcdf( 0.5, 2.0, 4.0 )\n ~-0.38\n > y = base.dists.kumaraswamy.logcdf( 0.2, 2.0, 2.0 )\n ~-2.546\n > y = base.dists.kumaraswamy.logcdf( 0.8, 4.0, 4.0 )\n ~-0.13\n > y = base.dists.kumaraswamy.logcdf( -0.5, 4.0, 2.0 )\n -Infinity\n > y = base.dists.kumaraswamy.logcdf( 1.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.kumaraswamy.logcdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.kumaraswamy.logcdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.kumaraswamy.logcdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.logcdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.kumaraswamy.logcdf.factory( a, b )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a Kumaraswamy's double bounded distribution\n with first shape parameter `a` and second shape parameter `b`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.kumaraswamy.logcdf.factory( 0.5, 1.0 );\n > var y = mylogcdf( 0.8 )\n ~-0.112\n > y = mylogcdf( 0.3 )\n ~-0.602\n\n"
+base.dists.kumaraswamy.logpdf,"\nbase.dists.kumaraswamy.logpdf( x, a, b )\n Evaluates the natural logarithm of the probability density function (PDF)\n for Kumaraswamy's double bounded distribution with first shape parameter `a`\n and second shape parameter `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.kumaraswamy.logpdf( 0.5, 1.0, 1.0 )\n 0.0\n > y = base.dists.kumaraswamy.logpdf( 0.5, 2.0, 4.0 )\n ~0.523\n > y = base.dists.kumaraswamy.logpdf( 0.2, 2.0, 2.0 )\n ~-0.264\n > y = base.dists.kumaraswamy.logpdf( 0.8, 4.0, 4.0 )\n ~0.522\n > y = base.dists.kumaraswamy.logpdf( -0.5, 4.0, 2.0 )\n -Infinity\n > y = base.dists.kumaraswamy.logpdf( 1.5, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.kumaraswamy.logpdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.kumaraswamy.logpdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.kumaraswamy.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.logpdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.kumaraswamy.logpdf.factory( a, b )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a Kumaraswamy's double bounded distribution with\n first shape parameter `a` and second shape parameter `b`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.kumaraswamy.logpdf.factory( 0.5, 1.0 );\n > var y = mylogpdf( 0.8 )\n ~-0.582\n > y = mylogpdf( 0.3 )\n ~-0.091\n\n"
+base.dists.kumaraswamy.mean,"\nbase.dists.kumaraswamy.mean( a, b )\n Returns the mean of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Mean.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.mean( 1.5, 1.5 )\n ~0.512\n > v = base.dists.kumaraswamy.mean( 4.0, 12.0 )\n ~0.481\n > v = base.dists.kumaraswamy.mean( 16.0, 8.0 )\n ~0.846\n\n"
+base.dists.kumaraswamy.median,"\nbase.dists.kumaraswamy.median( a, b )\n Returns the median of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.median( 1.0, 1.0 )\n 0.5\n > v = base.dists.kumaraswamy.median( 4.0, 12.0 )\n ~0.487\n > v = base.dists.kumaraswamy.median( 16.0, 8.0 )\n ~0.856\n\n"
+base.dists.kumaraswamy.mode,"\nbase.dists.kumaraswamy.mode( a, b )\n Returns the mode of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a < 1`, `b < 1`, or `a = b = 1`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.mode( 1.5, 1.5 )\n ~0.543\n > v = base.dists.kumaraswamy.mode( 4.0, 12.0 )\n ~0.503\n > v = base.dists.kumaraswamy.mode( 16.0, 8.0 )\n ~0.875\n\n"
+base.dists.kumaraswamy.pdf,"\nbase.dists.kumaraswamy.pdf( x, a, b )\n Evaluates the probability density function (PDF) for Kumaraswamy's double\n bounded distribution with first shape parameter `a` and second shape\n parameter `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.kumaraswamy.pdf( 0.5, 1.0, 1.0 )\n 1.0\n > y = base.dists.kumaraswamy.pdf( 0.5, 2.0, 4.0 )\n ~1.688\n > y = base.dists.kumaraswamy.pdf( 0.2, 2.0, 2.0 )\n ~0.768\n > y = base.dists.kumaraswamy.pdf( 0.8, 4.0, 4.0 )\n ~1.686\n > y = base.dists.kumaraswamy.pdf( -0.5, 4.0, 2.0 )\n 0.0\n > y = base.dists.kumaraswamy.pdf( 1.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.kumaraswamy.pdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.kumaraswamy.pdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.kumaraswamy.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.pdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.kumaraswamy.pdf.factory( a, b )\n Returns a function for evaluating the probability density function (PDF)\n of a Kumaraswamy's double bounded distribution with first shape parameter\n `a` and second shape parameter `b`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var mypdf = base.dists.kumaraswamy.pdf.factory( 0.5, 1.0 );\n > var y = mypdf( 0.8 )\n ~0.559\n > y = mypdf( 0.3 )\n ~0.913\n\n"
+base.dists.kumaraswamy.quantile,"\nbase.dists.kumaraswamy.quantile( p, a, b )\n Evaluates the quantile function for a Kumaraswamy's double bounded\n distribution with first shape parameter `a` and second shape parameter `b`\n at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.kumaraswamy.quantile( 0.5, 1.0, 1.0 )\n 0.5\n > y = base.dists.kumaraswamy.quantile( 0.5, 2.0, 4.0 )\n ~0.399\n > y = base.dists.kumaraswamy.quantile( 0.2, 2.0, 2.0 )\n ~0.325\n > y = base.dists.kumaraswamy.quantile( 0.8, 4.0, 4.0 )\n ~0.759\n\n > y = base.dists.kumaraswamy.quantile( -0.5, 4.0, 2.0 )\n NaN\n > y = base.dists.kumaraswamy.quantile( 1.5, 4.0, 2.0 )\n NaN\n\n > y = base.dists.kumaraswamy.quantile( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.kumaraswamy.quantile( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.kumaraswamy.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.kumaraswamy.quantile( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.kumaraswamy.quantile.factory( a, b )\n Returns a function for evaluating the quantile function of a Kumaraswamy's\n double bounded distribution with first shape parameter `a` and second shape\n parameter `b`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.kumaraswamy.quantile.factory( 0.5, 1.0 );\n > var y = myQuantile( 0.8 )\n ~0.64\n > y = myQuantile( 0.3 )\n ~0.09\n\n"
+base.dists.kumaraswamy.skewness,"\nbase.dists.kumaraswamy.skewness( a, b )\n Returns the skewness of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.skewness( 1.0, 1.0 )\n ~1.154e-15\n > v = base.dists.kumaraswamy.skewness( 4.0, 12.0 )\n ~-0.201\n > v = base.dists.kumaraswamy.skewness( 16.0, 8.0 )\n ~-0.94\n\n"
+base.dists.kumaraswamy.stdev,"\nbase.dists.kumaraswamy.stdev( a, b )\n Returns the standard deviation of a Kumaraswamy's double bounded\n distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.stdev( 1.0, 1.0 )\n ~0.289\n > v = base.dists.kumaraswamy.stdev( 4.0, 12.0 )\n ~0.13\n > v = base.dists.kumaraswamy.stdev( 16.0, 8.0 )\n ~0.062\n\n"
+base.dists.kumaraswamy.variance,"\nbase.dists.kumaraswamy.variance( a, b )\n Returns the variance of a Kumaraswamy's double bounded distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `a <= 0` or `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n First shape parameter.\n\n b: number\n Second shape parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.kumaraswamy.variance( 1.0, 1.0 )\n ~0.083\n > v = base.dists.kumaraswamy.variance( 4.0, 12.0 )\n ~0.017\n > v = base.dists.kumaraswamy.variance( 16.0, 8.0 )\n ~0.004\n\n"
+base.dists.laplace.cdf,"\nbase.dists.laplace.cdf( x, μ, b )\n Evaluates the cumulative distribution function (CDF) for a Laplace\n distribution with scale parameter `b` and location parameter `μ` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.laplace.cdf( 2.0, 0.0, 1.0 )\n ~0.932\n > y = base.dists.laplace.cdf( 5.0, 10.0, 3.0 )\n ~0.094\n > y = base.dists.laplace.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.cdf( 2, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.cdf( 2.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.laplace.cdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.cdf.factory( μ, b )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Laplace distribution with scale parameter `b` and location parameter\n `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.laplace.cdf.factory( 2.0, 3.0 );\n > var y = myCDF( 10.0 )\n ~0.965\n > y = myCDF( 2.0 )\n 0.5\n\n"
+base.dists.laplace.entropy,"\nbase.dists.laplace.entropy( μ, b )\n Returns the differential entropy of a Laplace distribution with location\n parameter `μ` and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Differential entropy.\n\n Examples\n --------\n > var y = base.dists.laplace.entropy( 0.0, 1.0 )\n ~1.693\n > y = base.dists.laplace.entropy( 4.0, 2.0 )\n ~2.386\n > y = base.dists.laplace.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.entropy( 0.0, NaN )\n NaN\n > y = base.dists.laplace.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.kurtosis,"\nbase.dists.laplace.kurtosis( μ, b )\n Returns the excess kurtosis of a Laplace distribution with location\n parameter `μ` and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.laplace.kurtosis( 0.0, 1.0 )\n 3.0\n > y = base.dists.laplace.kurtosis( 4.0, 2.0 )\n 3.0\n > y = base.dists.laplace.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.laplace.kurtosis( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.Laplace,"\nbase.dists.laplace.Laplace( [μ, b] )\n Returns a Laplace distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n b: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n laplace: Object\n Distribution instance.\n\n laplace.mu: number\n Location parameter.\n\n laplace.b: number\n Scale parameter. If set, the value must be greater than `0`.\n\n laplace.entropy: number\n Read-only property which returns the differential entropy.\n\n laplace.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n laplace.mean: number\n Read-only property which returns the expected value.\n\n laplace.median: number\n Read-only property which returns the median.\n\n laplace.mode: number\n Read-only property which returns the mode.\n\n laplace.skewness: number\n Read-only property which returns the skewness.\n\n laplace.stdev: number\n Read-only property which returns the standard deviation.\n\n laplace.variance: number\n Read-only property which returns the variance.\n\n laplace.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n laplace.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n laplace.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n laplace.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n laplace.pdf: Function\n Evaluates the probability density function (PDF).\n\n laplace.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var laplace = base.dists.laplace.Laplace( -2.0, 3.0 );\n > laplace.mu\n -2.0\n > laplace.b\n 3.0\n > laplace.entropy\n ~2.792\n > laplace.kurtosis\n 3.0\n > laplace.mean\n -2.0\n > laplace.median\n -2.0\n > laplace.mode\n -2.0\n > laplace.skewness\n 0.0\n > laplace.stdev\n ~4.243\n > laplace.variance\n 18.0\n > laplace.cdf( 0.8 )\n ~0.803\n > laplace.logcdf( 0.8 )\n ~-0.219\n > laplace.logpdf( 1.0 )\n ~-2.792\n > laplace.mgf( 0.2 )\n ~1.047\n > laplace.pdf( 2.0 )\n ~0.044\n > laplace.quantile( 0.9 )\n ~2.828\n\n"
+base.dists.laplace.logcdf,"\nbase.dists.laplace.logcdf( x, μ, b )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n Laplace distribution with scale parameter `b` and location parameter `μ` at\n a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.laplace.logcdf( 2.0, 0.0, 1.0 )\n ~-0.07\n > y = base.dists.laplace.logcdf( 5.0, 10.0, 3.0 )\n ~-2.36\n > y = base.dists.laplace.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.logcdf( 2, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.logcdf( 2.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.laplace.logcdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.logcdf.factory( μ, b )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Laplace distribution with scale parameter\n `b` and location parameter `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.laplace.logcdf.factory( 2.0, 3.0 );\n > var y = mylogcdf( 10.0 )\n ~-0.035\n > y = mylogcdf( 2.0 )\n ~-0.693\n\n"
+base.dists.laplace.logpdf,"\nbase.dists.laplace.logpdf( x, μ, b )\n Evaluates the logarithm of the probability density function (PDF) for a\n Laplace distribution with scale parameter `b` and location parameter `μ` at\n a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.laplace.logpdf( 2.0, 0.0, 1.0 )\n ~-2.693\n > y = base.dists.laplace.logpdf( -1.0, 2.0, 3.0 )\n ~-2.792\n > y = base.dists.laplace.logpdf( 2.5, 2.0, 3.0 )\n ~-1.958\n > y = base.dists.laplace.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.logpdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.laplace.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.logpdf.factory( μ, b )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Laplace distribution with scale parameter `b` and\n location parameter `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.laplace.logpdf.factory( 10.0, 2.0 );\n > var y = mylogPDF( 10.0 )\n ~-1.386\n\n"
+base.dists.laplace.mean,"\nbase.dists.laplace.mean( μ, b )\n Returns the expected value of a Laplace distribution with location parameter\n `μ` and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.laplace.mean( 0.0, 1.0 )\n 0.0\n > y = base.dists.laplace.mean( 4.0, 2.0 )\n 4.0\n > y = base.dists.laplace.mean( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.mean( 0.0, NaN )\n NaN\n > y = base.dists.laplace.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.median,"\nbase.dists.laplace.median( μ, b )\n Returns the median of a Laplace distribution with location parameter `μ` and\n scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.laplace.median( 0.0, 1.0 )\n 0.0\n > y = base.dists.laplace.median( 4.0, 2.0 )\n 4.0\n > y = base.dists.laplace.median( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.median( 0.0, NaN )\n NaN\n > y = base.dists.laplace.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.mgf,"\nbase.dists.laplace.mgf( t, μ, b )\n Evaluates the moment-generating function (MGF) for a Laplace\n distribution with scale parameter `b` and location parameter `μ` at a\n value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.laplace.mgf( 0.5, 0.0, 1.0 )\n ~1.333\n > y = base.dists.laplace.mgf( 0.0, 0.0, 1.0 )\n 1.0\n > y = base.dists.laplace.mgf( -1.0, 4.0, 0.2 )\n ~0.019\n > y = base.dists.laplace.mgf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.mgf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.laplace.mgf( 1.0, 0.0, 2.0 )\n NaN\n > y = base.dists.laplace.mgf( -0.5, 0.0, 4.0 )\n NaN\n > y = base.dists.laplace.mgf( 2.0, 0.0, 0.0 )\n NaN\n > y = base.dists.laplace.mgf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.mgf.factory( μ, b )\n Returns a function for evaluating the moment-generating function (MGF)\n of a Laplace distribution with scale parameter `b` and location parameter\n `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.laplace.mgf.factory( 4.0, 2.0 );\n > var y = mymgf( 0.2 )\n ~2.649\n > y = mymgf( 0.4 )\n ~13.758\n\n"
+base.dists.laplace.mode,"\nbase.dists.laplace.mode( μ, b )\n Returns the mode of a Laplace distribution with location parameter `μ` and\n scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.laplace.mode( 0.0, 1.0 )\n 0.0\n > y = base.dists.laplace.mode( 4.0, 2.0 )\n 4.0\n > y = base.dists.laplace.mode( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.mode( 0.0, NaN )\n NaN\n > y = base.dists.laplace.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.pdf,"\nbase.dists.laplace.pdf( x, μ, b )\n Evaluates the probability density function (PDF) for a Laplace\n distribution with scale parameter `b` and location parameter `μ` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.laplace.pdf( 2.0, 0.0, 1.0 )\n ~0.068\n > y = base.dists.laplace.pdf( -1.0, 2.0, 3.0 )\n ~0.061\n > y = base.dists.laplace.pdf( 2.5, 2.0, 3.0 )\n ~0.141\n > y = base.dists.laplace.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.laplace.pdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.pdf.factory( μ, b )\n Returns a function for evaluating the probability density function (PDF)\n of a Laplace distribution with scale parameter `b` and location parameter\n `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.laplace.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 10.0 )\n 0.25\n\n"
+base.dists.laplace.quantile,"\nbase.dists.laplace.quantile( p, μ, b )\n Evaluates the quantile function for a Laplace distribution with scale\n parameter `b` and location parameter `μ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.laplace.quantile( 0.8, 0.0, 1.0 )\n ~0.916\n > y = base.dists.laplace.quantile( 0.5, 4.0, 2.0 )\n 4.0\n\n > y = base.dists.laplace.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.laplace.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.laplace.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.laplace.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.laplace.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.laplace.quantile.factory( μ, b )\n Returns a function for evaluating the quantile function of a Laplace\n distribution with scale parameter `b` and location parameter `μ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.laplace.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n 10.0\n > y = myQuantile( 0.8 )\n ~11.833\n\n"
+base.dists.laplace.skewness,"\nbase.dists.laplace.skewness( μ, b )\n Returns the skewness of a Laplace distribution with location parameter `μ`\n and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.laplace.skewness( 0.0, 1.0 )\n 0.0\n > y = base.dists.laplace.skewness( 4.0, 2.0 )\n 0.0\n > y = base.dists.laplace.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.skewness( 0.0, NaN )\n NaN\n > y = base.dists.laplace.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.stdev,"\nbase.dists.laplace.stdev( μ, b )\n Returns the standard deviation of a Laplace distribution with location\n parameter `μ` and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.laplace.stdev( 0.0, 1.0 )\n ~1.414\n > y = base.dists.laplace.stdev( 4.0, 2.0 )\n ~2.828\n > y = base.dists.laplace.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.stdev( 0.0, NaN )\n NaN\n > y = base.dists.laplace.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.laplace.variance,"\nbase.dists.laplace.variance( μ, b )\n Returns the variance of a Laplace distribution with location parameter `μ`\n and scale parameter `b`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `b <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n b: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.laplace.variance( 0.0, 1.0 )\n 2.0\n > y = base.dists.laplace.variance( 4.0, 2.0 )\n 8.0\n > y = base.dists.laplace.variance( NaN, 1.0 )\n NaN\n > y = base.dists.laplace.variance( 0.0, NaN )\n NaN\n > y = base.dists.laplace.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.cdf,"\nbase.dists.levy.cdf( x, μ, c )\n Evaluates the cumulative distribution function (CDF) for a Lévy distribution\n with location parameter `μ` and scale parameter `c` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.levy.cdf( 2.0, 0.0, 1.0 )\n ~0.48\n > y = base.dists.levy.cdf( 12.0, 10.0, 3.0 )\n ~0.221\n > y = base.dists.levy.cdf( 9.0, 10.0, 3.0 )\n 0.0\n > y = base.dists.levy.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.cdf( 2, NaN, 1.0 )\n NaN\n > y = base.dists.levy.cdf( 2.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.levy.cdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.levy.cdf.factory( μ, c )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Lévy distribution with location parameter `μ` and scale parameter `c`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.levy.cdf.factory( 2.0, 3.0 );\n > var y = myCDF( 10.0 )\n ~0.54\n > y = myCDF( 2.0 )\n 0.0\n\n"
+base.dists.levy.entropy,"\nbase.dists.levy.entropy( μ, c )\n Returns the entropy of a Lévy distribution with location parameter `μ` and\n scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.levy.entropy( 0.0, 1.0 )\n ~3.324\n > y = base.dists.levy.entropy( 4.0, 2.0 )\n ~4.018\n > y = base.dists.levy.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.levy.entropy( 0.0, NaN )\n NaN\n > y = base.dists.levy.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.Levy,"\nbase.dists.levy.Levy( [μ, c] )\n Returns a Lévy distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n c: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n levy: Object\n Distribution instance.\n\n levy.mu: number\n Location parameter.\n\n levy.c: number\n Scale parameter. If set, the value must be greater than `0`.\n\n levy.entropy: number\n Read-only property which returns the differential entropy.\n\n levy.mean: number\n Read-only property which returns the expected value.\n\n levy.median: number\n Read-only property which returns the median.\n\n levy.mode: number\n Read-only property which returns the mode.\n\n levy.stdev: number\n Read-only property which returns the standard deviation.\n\n levy.variance: number\n Read-only property which returns the variance.\n\n levy.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n levy.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n levy.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n levy.pdf: Function\n Evaluates the probability density function (PDF).\n\n levy.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var levy = base.dists.levy.Levy( -2.0, 3.0 );\n > levy.mu\n -2.0\n > levy.c\n 3.0\n > levy.entropy\n ~4.423\n > levy.mean\n Infinity\n > levy.median\n ~4.594\n > levy.mode\n -1.0\n > levy.stdev\n Infinity\n > levy.variance\n Infinity\n > levy.cdf( 0.8 )\n ~0.3\n > levy.logcdf( 0.8 )\n ~-1.2\n > levy.logpdf( 1.0 )\n ~-2.518\n > levy.pdf( 1.0 )\n ~0.081\n > levy.quantile( 0.8 )\n ~44.74\n\n"
+base.dists.levy.logcdf,"\nbase.dists.levy.logcdf( x, μ, c )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n Lévy distribution with location parameter `μ` and scale parameter `c` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.levy.logcdf( 2.0, 0.0, 1.0 )\n ~-0.735\n > y = base.dists.levy.logcdf( 12.0, 10.0, 3.0 )\n ~-1.51\n > y = base.dists.levy.logcdf( 9.0, 10.0, 3.0 )\n -Infinity\n > y = base.dists.levy.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.logcdf( 2, NaN, 1.0 )\n NaN\n > y = base.dists.levy.logcdf( 2.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.levy.logcdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.levy.logcdf.factory( μ, c )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Lévy distribution with location parameter\n `μ` and scale parameter `c`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.levy.logcdf.factory( 2.0, 3.0 );\n > var y = mylogcdf( 10.0 )\n ~-0.616\n > y = mylogcdf( 2.0 )\n -Infinity\n\n"
+base.dists.levy.logpdf,"\nbase.dists.levy.logpdf( x, μ, c )\n Evaluates the logarithm of the probability density function (PDF) for a Lévy\n distribution with location parameter `μ` and scale parameter `c` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.levy.logpdf( 2.0, 0.0, 1.0 )\n ~-2.209\n > y = base.dists.levy.logpdf( -1.0, 4.0, 2.0 )\n -Infinity\n > y = base.dists.levy.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.levy.logpdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.levy.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.levy.logpdf.factory( μ, c )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Lévy distribution with location parameter `μ` and scale\n parameter `c`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.levy.logpdf.factory( 10.0, 2.0 );\n > var y = mylogPDF( 11.0 )\n ~-1.572\n\n"
+base.dists.levy.mean,"\nbase.dists.levy.mean( μ, c )\n Returns the expected value of a Lévy distribution with location parameter\n `μ` and scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.levy.mean( 0.0, 1.0 )\n Infinity\n > y = base.dists.levy.mean( 4.0, 3.0 )\n Infinity\n > y = base.dists.levy.mean( NaN, 1.0 )\n NaN\n > y = base.dists.levy.mean( 0.0, NaN )\n NaN\n > y = base.dists.levy.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.median,"\nbase.dists.levy.median( μ, c )\n Returns the median of a Lévy distribution with location parameter `μ` and\n scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.levy.median( 0.0, 1.0 )\n ~2.198\n > y = base.dists.levy.median( 4.0, 3.0 )\n ~10.594\n > y = base.dists.levy.median( NaN, 1.0 )\n NaN\n > y = base.dists.levy.median( 0.0, NaN )\n NaN\n > y = base.dists.levy.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.mode,"\nbase.dists.levy.mode( μ, c )\n Returns the mode of a Lévy distribution with location parameter `μ` and\n scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.levy.mode( 0.0, 1.0 )\n ~0.333\n > y = base.dists.levy.mode( 4.0, 3.0 )\n 5.0\n > y = base.dists.levy.mode( NaN, 1.0 )\n NaN\n > y = base.dists.levy.mode( 0.0, NaN )\n NaN\n > y = base.dists.levy.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.pdf,"\nbase.dists.levy.pdf( x, μ, c )\n Evaluates the probability density function (PDF) for a Lévy distribution\n with location parameter `μ` and scale parameter `c` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.levy.pdf( 2.0, 0.0, 1.0 )\n ~0.11\n > y = base.dists.levy.pdf( -1.0, 4.0, 2.0 )\n 0.0\n > y = base.dists.levy.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.levy.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.levy.pdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.levy.pdf.factory( μ, c )\n Returns a function for evaluating the probability density function (PDF) of\n a Lévy distribution with location parameter `μ` and scale parameter `c`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.levy.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 11.0 )\n ~0.208\n\n"
+base.dists.levy.quantile,"\nbase.dists.levy.quantile( p, μ, c )\n Evaluates the quantile function for a Lévy distribution with location\n parameter `μ` and scale parameter `c` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.levy.quantile( 0.8, 0.0, 1.0 )\n ~15.58\n > y = base.dists.levy.quantile( 0.5, 4.0, 2.0 )\n ~8.396\n\n > y = base.dists.levy.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.levy.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.levy.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.levy.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.levy.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.levy.quantile.factory( μ, c )\n Returns a function for evaluating the quantile function of a Lévy\n distribution with location parameter `μ` and scale parameter `c`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.levy.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n ~14.396\n\n"
+base.dists.levy.stdev,"\nbase.dists.levy.stdev( μ, c )\n Returns the standard deviation of a Lévy distribution with location\n parameter `μ` and scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.levy.stdev( 0.0, 1.0 )\n Infinity\n > y = base.dists.levy.stdev( 4.0, 3.0 )\n Infinity\n > y = base.dists.levy.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.levy.stdev( 0.0, NaN )\n NaN\n > y = base.dists.levy.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.levy.variance,"\nbase.dists.levy.variance( μ, c )\n Returns the variance of a Lévy distribution with location parameter `μ` and\n scale parameter `c`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `c <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n c: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.levy.variance( 0.0, 1.0 )\n Infinity\n > y = base.dists.levy.variance( 4.0, 3.0 )\n Infinity\n > y = base.dists.levy.variance( NaN, 1.0 )\n NaN\n > y = base.dists.levy.variance( 0.0, NaN )\n NaN\n > y = base.dists.levy.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.cdf,"\nbase.dists.logistic.cdf( x, μ, s )\n Evaluates the cumulative distribution function (CDF) for a logistic\n distribution with location parameter `μ` and scale parameter `s` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.logistic.cdf( 2.0, 0.0, 1.0 )\n ~0.881\n > y = base.dists.logistic.cdf( 5.0, 10.0, 3.0 )\n ~0.159\n\n > y = base.dists.logistic.cdf( 2.0, 0.0, NaN )\n NaN\n > y = base.dists.logistic.cdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.cdf( NaN, 0.0, 1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `s = 0.0`:\n > y = base.dists.logistic.cdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.logistic.cdf( 8.0, 8.0, 0.0 )\n 1.0\n > y = base.dists.logistic.cdf( 10.0, 8.0, 0.0 )\n 1.0\n\n\nbase.dists.logistic.cdf.factory( μ, s )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a logistic distribution with location parameter `μ` and scale parameter\n `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.logistic.cdf.factory( 3.0, 1.5 );\n > var y = mycdf( 1.0 )\n ~0.209\n\n"
+base.dists.logistic.entropy,"\nbase.dists.logistic.entropy( μ, s )\n Returns the entropy of a logistic distribution with location parameter `μ`\n and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.logistic.entropy( 0.0, 1.0 )\n 2.0\n > y = base.dists.logistic.entropy( 4.0, 2.0 )\n ~2.693\n > y = base.dists.logistic.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.entropy( 0.0, NaN )\n NaN\n > y = base.dists.logistic.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.kurtosis,"\nbase.dists.logistic.kurtosis( μ, s )\n Returns the excess kurtosis of a logistic distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.logistic.kurtosis( 0.0, 1.0 )\n 1.2\n > y = base.dists.logistic.kurtosis( 4.0, 2.0 )\n 1.2\n > y = base.dists.logistic.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.logistic.kurtosis( 0.0, 0.0 )\n NaN\n\n\n"
+base.dists.logistic.logcdf,"\nbase.dists.logistic.logcdf( x, μ, s )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n logistic distribution with location parameter `μ` and scale parameter `s` at\n a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.logistic.logcdf( 2.0, 0.0, 1.0 )\n ~-0.127\n > y = base.dists.logistic.logcdf( 5.0, 10.0, 3.0 )\n ~-1.84\n > y = base.dists.logistic.logcdf( 2.0, 0.0, NaN )\n NaN\n > y = base.dists.logistic.logcdf( 2, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.logcdf( NaN, 0.0, 1.0 )\n NaN\n\n\nbase.dists.logistic.logcdf.factory( μ, s )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Logistic distribution with location\n parameter `μ` and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.logistic.logcdf.factory( 3.0, 1.5 );\n > var y = mylogcdf( 1.0 )\n ~-1.567\n\n"
+base.dists.logistic.Logistic,"\nbase.dists.logistic.Logistic( [μ, s] )\n Returns a logistic distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n s: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n logistic: Object\n Distribution instance.\n\n logistic.mu: number\n Location parameter.\n\n logistic.s: number\n Scale parameter. If set, the value must be greater than `0`.\n\n logistic.entropy: number\n Read-only property which returns the differential entropy.\n\n logistic.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n logistic.mean: number\n Read-only property which returns the expected value.\n\n logistic.median: number\n Read-only property which returns the median.\n\n logistic.mode: number\n Read-only property which returns the mode.\n\n logistic.skewness: number\n Read-only property which returns the skewness.\n\n logistic.stdev: number\n Read-only property which returns the standard deviation.\n\n logistic.variance: number\n Read-only property which returns the variance.\n\n logistic.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n logistic.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n logistic.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n logistic.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n logistic.pdf: Function\n Evaluates the probability density function (PDF).\n\n logistic.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var logistic = base.dists.logistic.Logistic( -2.0, 3.0 );\n > logistic.mu\n -2.0\n > logistic.s\n 3.0\n > logistic.entropy\n ~3.1\n > logistic.kurtosis\n 1.2\n > logistic.mean\n -2.0\n > logistic.median\n -2.0\n > logistic.mode\n -2.0\n > logistic.skewness\n 0.0\n > logistic.stdev\n ~5.441\n > logistic.variance\n ~29.609\n > logistic.cdf( 0.8 )\n ~0.718\n > logistic.logcdf( 0.8 )\n ~-0.332\n > logistic.logpdf( 2.0 )\n ~-2.9\n > logistic.mgf( 0.2 )\n ~1.329\n > logistic.pdf( 2.0 )\n ~0.055\n > logistic.quantile( 0.9 )\n ~4.592\n\n"
+base.dists.logistic.logpdf,"\nbase.dists.logistic.logpdf( x, μ, s )\n Evaluates the logarithm of the probability density function (PDF) for a\n logistic distribution with location parameter `μ` and scale parameter `s` at\n a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.logistic.logpdf( 2.0, 0.0, 1.0 )\n ~-2.254\n > y = base.dists.logistic.logpdf( -1.0, 4.0, 2.0 )\n ~-3.351\n > y = base.dists.logistic.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.logistic.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.logpdf( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.logistic.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution at `s = 0.0`:\n > y = base.dists.logistic.logpdf( 2.0, 8.0, 0.0 )\n -Infinity\n > y = base.dists.logistic.logpdf( 8.0, 8.0, 0.0 )\n Infinity\n\n\nbase.dists.logistic.logpdf.factory( μ, s )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Logistic distribution with location parameter `μ` and\n scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.logistic.logpdf.factory( 10.0, 2.0 );\n > var y = mylogpdf( 10.0 )\n ~-2.079\n\n"
+base.dists.logistic.mean,"\nbase.dists.logistic.mean( μ, s )\n Returns the expected value of a logistic distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.logistic.mean( 0.0, 1.0 )\n 0.0\n > y = base.dists.logistic.mean( 4.0, 2.0 )\n 4.0\n > y = base.dists.logistic.mean( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.mean( 0.0, NaN )\n NaN\n > y = base.dists.logistic.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.median,"\nbase.dists.logistic.median( μ, s )\n Returns the median of a logistic distribution with location parameter `μ`\n and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.logistic.median( 0.0, 1.0 )\n 0.0\n > y = base.dists.logistic.median( 4.0, 2.0 )\n 4.0\n > y = base.dists.logistic.median( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.median( 0.0, NaN )\n NaN\n > y = base.dists.logistic.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.mgf,"\nbase.dists.logistic.mgf( t, μ, s )\n Evaluates the moment-generating function (MGF) for a logistic distribution\n with location parameter `μ` and scale parameter `s` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.logistic.mgf( 0.9, 0.0, 1.0 )\n ~9.15\n > y = base.dists.logistic.mgf( 0.1, 4.0, 4.0 )\n ~1.971\n > y = base.dists.logistic.mgf( -0.2, 4.0, 4.0 )\n ~1.921\n > y = base.dists.logistic.mgf( 0.5, 0.0, -1.0 )\n NaN\n > y = base.dists.logistic.mgf( 0.5, 0.0, 4.0 )\n Infinity\n > y = base.dists.logistic.mgf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.logistic.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.mgf( 0.0, 0.0, NaN )\n NaN\n\n\nbase.dists.logistic.mgf.factory( μ, s )\n Returns a function for evaluating the moment-generating function (MGF)\n of a Logistic distribution with location parameter `μ` and scale parameter\n `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.logistic.mgf.factory( 10.0, 0.5 );\n > var y = mymgf( 0.5 )\n ~164.846\n > y = mymgf( 2.0 )\n Infinity\n\n"
+base.dists.logistic.mode,"\nbase.dists.logistic.mode( μ, s )\n Returns the mode of a logistic distribution with location parameter `μ` and\n scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.logistic.mode( 0.0, 1.0 )\n 0.0\n > y = base.dists.logistic.mode( 4.0, 2.0 )\n 4.0\n > y = base.dists.logistic.mode( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.mode( 0.0, NaN )\n NaN\n > y = base.dists.logistic.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.pdf,"\nbase.dists.logistic.pdf( x, μ, s )\n Evaluates the probability density function (PDF) for a logistic distribution\n with location parameter `μ` and scale parameter `s` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.logistic.pdf( 2.0, 0.0, 1.0 )\n ~0.105\n > y = base.dists.logistic.pdf( -1.0, 4.0, 2.0 )\n ~0.035\n > y = base.dists.logistic.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.logistic.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.pdf( 0.0, 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.logistic.pdf( 2.0, 0.0, -1.0 )\n NaN\n > y = base.dists.logistic.pdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.logistic.pdf( 8.0, 8.0, 0.0 )\n Infinity\n\n\nbase.dists.logistic.pdf.factory( μ, s )\n Returns a function for evaluating the probability density function (PDF) of\n a Logistic distribution with location parameter `μ` and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.logistic.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 10.0 )\n 0.125\n\n"
+base.dists.logistic.quantile,"\nbase.dists.logistic.quantile( p, μ, s )\n Evaluates the quantile function for a logistic distribution with location\n parameter `μ` and scale parameter `s` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.logistic.quantile( 0.8, 0.0, 1.0 )\n ~1.386\n > y = base.dists.logistic.quantile( 0.5, 4.0, 2.0 )\n 4\n\n > y = base.dists.logistic.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.logistic.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.logistic.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.logistic.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.logistic.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.logistic.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n\nbase.dists.logistic.quantile.factory( μ, s )\n Returns a function for evaluating the quantile function of a logistic\n distribution with location parameter `μ` and scale parameter `s`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.logistic.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n 10.0\n\n"
+base.dists.logistic.skewness,"\nbase.dists.logistic.skewness( μ, s )\n Returns the skewness of a logistic distribution with location parameter `μ`\n and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.logistic.skewness( 0.0, 1.0 )\n 0.0\n > y = base.dists.logistic.skewness( 4.0, 2.0 )\n 0.0\n > y = base.dists.logistic.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.skewness( 0.0, NaN )\n NaN\n > y = base.dists.logistic.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.stdev,"\nbase.dists.logistic.stdev( μ, s )\n Returns the standard deviation of a logistic distribution with location\n parameter `μ` and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.logistic.stdev( 0.0, 1.0 )\n ~1.814\n > y = base.dists.logistic.stdev( 4.0, 2.0 )\n ~3.628\n > y = base.dists.logistic.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.stdev( 0.0, NaN )\n NaN\n > y = base.dists.logistic.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.logistic.variance,"\nbase.dists.logistic.variance( μ, s )\n Returns the variance of a logistic distribution with location parameter `μ`\n and scale parameter `s`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.logistic.variance( 0.0, 1.0 )\n ~3.29\n > y = base.dists.logistic.variance( 4.0, 2.0 )\n ~13.159\n > y = base.dists.logistic.variance( NaN, 1.0 )\n NaN\n > y = base.dists.logistic.variance( 0.0, NaN )\n NaN\n > y = base.dists.logistic.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.cdf,"\nbase.dists.lognormal.cdf( x, μ, σ )\n Evaluates the cumulative distribution function (CDF) for a lognormal\n distribution with location parameter `μ` and scale parameter `σ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.lognormal.cdf( 2.0, 0.0, 1.0 )\n ~0.756\n > y = base.dists.lognormal.cdf( 5.0, 10.0, 3.0 )\n ~0.003\n\n > y = base.dists.lognormal.cdf( 2.0, 0.0, NaN )\n NaN\n > y = base.dists.lognormal.cdf( 2.0, NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.cdf( NaN, 0.0, 1.0 )\n NaN\n\n // Non-positive scale parameter `σ`:\n > y = base.dists.lognormal.cdf( 2.0, 0.0, -1.0 )\n NaN\n > y = base.dists.lognormal.cdf( 2.0, 0.0, 0.0 )\n NaN\n\n\nbase.dists.lognormal.cdf.factory( μ, σ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a lognormal distribution with location parameter `μ` and scale parameter\n `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.lognormal.cdf.factory( 3.0, 1.5 );\n > var y = myCDF( 1.0 )\n ~0.023\n > y = myCDF( 4.0 )\n ~0.141\n\n"
+base.dists.lognormal.entropy,"\nbase.dists.lognormal.entropy( μ, σ )\n Returns the differential entropy of a lognormal distribution with location\n `μ` and scale `σ` (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.lognormal.entropy( 0.0, 1.0 )\n ~1.419\n > y = base.dists.lognormal.entropy( 5.0, 2.0 )\n ~7.112\n > y = base.dists.lognormal.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.entropy( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.kurtosis,"\nbase.dists.lognormal.kurtosis( μ, σ )\n Returns the excess kurtosis of a lognormal distribution with location `μ`\n and scale `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Kurtosis.\n\n Examples\n --------\n > var y = base.dists.lognormal.kurtosis( 0.0, 1.0 )\n ~110.936\n > y = base.dists.lognormal.kurtosis( 5.0, 2.0 )\n ~9220556.977\n > y = base.dists.lognormal.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.kurtosis( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.LogNormal,"\nbase.dists.lognormal.LogNormal( [μ, σ] )\n Returns a lognormal distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter. Default: `0.0`.\n\n σ: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n lognormal: Object\n Distribution instance.\n\n lognormal.mu: number\n Location parameter.\n\n lognormal.sigma: number\n Scale parameter. If set, the value must be greater than `0`.\n\n lognormal.entropy: number\n Read-only property which returns the differential entropy.\n\n lognormal.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n lognormal.mean: number\n Read-only property which returns the expected value.\n\n lognormal.median: number\n Read-only property which returns the median.\n\n lognormal.mode: number\n Read-only property which returns the mode.\n\n lognormal.skewness: number\n Read-only property which returns the skewness.\n\n lognormal.stdev: number\n Read-only property which returns the standard deviation.\n\n lognormal.variance: number\n Read-only property which returns the variance.\n\n lognormal.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n lognormal.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n lognormal.pdf: Function\n Evaluates the probability density function (PDF).\n\n lognormal.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var lognormal = base.dists.lognormal.LogNormal( -2.0, 3.0 );\n > lognormal.mu\n -2.0\n > lognormal.sigma\n 3.0\n > lognormal.entropy\n ~0.518\n > lognormal.kurtosis\n 4312295840576300\n > lognormal.mean\n ~12.182\n > lognormal.median\n ~0.135\n > lognormal.mode\n ~0.0\n > lognormal.skewness\n ~729551.383\n > lognormal.stdev\n ~1096.565\n > lognormal.variance\n ~1202455.871\n > lognormal.cdf( 0.8 )\n ~0.723\n > lognormal.logpdf( 2.0 )\n ~-3.114\n > lognormal.pdf( 2.0 )\n ~0.044\n > lognormal.quantile( 0.9 )\n ~6.326\n\n"
+base.dists.lognormal.logpdf,"\nbase.dists.lognormal.logpdf( x, μ, σ )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a lognormal distribution with location parameter `μ` and scale parameter\n `σ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.lognormal.logpdf( 2.0, 0.0, 1.0 )\n ~-1.852\n > y = base.dists.lognormal.logpdf( 1.0, 0.0, 1.0 )\n ~-0.919\n > y = base.dists.lognormal.logpdf( 1.0, 3.0, 1.0 )\n ~-5.419\n > y = base.dists.lognormal.logpdf( -1.0, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.lognormal.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.lognormal.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.logpdf( 0.0, 0.0, NaN )\n NaN\n\n // Non-positive scale parameter `σ`:\n > y = base.dists.lognormal.logpdf( 2.0, 0.0, -1.0 )\n NaN\n > y = base.dists.lognormal.logpdf( 2.0, 0.0, 0.0 )\n NaN\n\n\nbase.dists.lognormal.logpdf.factory( μ, σ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a lognormal distribution with location parameter\n `μ` and scale parameter `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.lognormal.logpdf.factory( 4.0, 2.0 );\n > var y = mylogPDF( 10.0 )\n ~-4.275\n > y = mylogPDF( 2.0 )\n ~-3.672\n\n"
+base.dists.lognormal.mean,"\nbase.dists.lognormal.mean( μ, σ )\n Returns the expected value of a lognormal distribution with location `μ` and\n scale `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.lognormal.mean( 0.0, 1.0 )\n ~1.649\n > y = base.dists.lognormal.mean( 4.0, 2.0 )\n ~403.429\n > y = base.dists.lognormal.mean( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.mean( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.median,"\nbase.dists.lognormal.median( μ, σ )\n Returns the median of a lognormal distribution with location `μ` and scale\n `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.lognormal.median( 0.0, 1.0 )\n 1.0\n > y = base.dists.lognormal.median( 5.0, 2.0 )\n ~148.413\n > y = base.dists.lognormal.median( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.median( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.mode,"\nbase.dists.lognormal.mode( μ, σ )\n Returns the mode of a lognormal distribution with location `μ` and scale\n `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.lognormal.mode( 0.0, 1.0 )\n ~0.368\n > y = base.dists.lognormal.mode( 5.0, 2.0 )\n ~2.718\n > y = base.dists.lognormal.mode( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.mode( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.pdf,"\nbase.dists.lognormal.pdf( x, μ, σ )\n Evaluates the probability density function (PDF) for a lognormal\n distribution with location parameter `μ` and scale parameter `σ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.lognormal.pdf( 2.0, 0.0, 1.0 )\n ~0.157\n > y = base.dists.lognormal.pdf( 1.0, 0.0, 1.0 )\n ~0.399\n > y = base.dists.lognormal.pdf( 1.0, 3.0, 1.0 )\n ~0.004\n > y = base.dists.lognormal.pdf( -1.0, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.lognormal.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.lognormal.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.pdf( 0.0, 0.0, NaN )\n NaN\n\n // Non-positive scale parameter `σ`:\n > y = base.dists.lognormal.pdf( 2.0, 0.0, -1.0 )\n NaN\n > y = base.dists.lognormal.pdf( 2.0, 0.0, 0.0 )\n NaN\n\n\nbase.dists.lognormal.pdf.factory( μ, σ )\n Returns a function for evaluating the probability density function (PDF) of\n a lognormal distribution with location parameter `μ` and scale parameter\n `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.lognormal.pdf.factory( 4.0, 2.0 );\n > var y = myPDF( 10.0 )\n ~0.014\n > y = myPDF( 2.0 )\n ~0.025\n\n"
+base.dists.lognormal.quantile,"\nbase.dists.lognormal.quantile( p, μ, σ )\n Evaluates the quantile function for a lognormal distribution with location\n parameter `μ` and scale parameter `σ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.lognormal.quantile( 0.8, 0.0, 1.0 )\n ~2.32\n > y = base.dists.lognormal.quantile( 0.5, 4.0, 2.0 )\n ~54.598\n > y = base.dists.lognormal.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.lognormal.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.lognormal.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.lognormal.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Non-positive scale parameter `σ`:\n > y = base.dists.lognormal.quantile( 0.5, 0.0, -1.0 )\n NaN\n > y = base.dists.lognormal.quantile( 0.5, 0.0, 0.0 )\n NaN\n\n\nbase.dists.lognormal.quantile.factory( μ, σ )\n Returns a function for evaluating the quantile function of a lognormal\n distribution with location parameter `μ` and scale parameter `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.lognormal.quantile.factory( 4.0, 2.0 );\n > var y = myQuantile( 0.2 )\n ~10.143\n > y = myQuantile( 0.8 )\n ~293.901\n\n"
+base.dists.lognormal.skewness,"\nbase.dists.lognormal.skewness( μ, σ )\n Returns the skewness of a lognormal distribution with location `μ` and scale\n `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.lognormal.skewness( 0.0, 1.0 )\n ~6.185\n > y = base.dists.lognormal.skewness( 5.0, 2.0 )\n ~414.359\n > y = base.dists.lognormal.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.skewness( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.stdev,"\nbase.dists.lognormal.stdev( μ, σ )\n Returns the standard deviation of a lognormal distribution with location `μ`\n and scale `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.lognormal.stdev( 0.0, 1.0 )\n ~2.161\n > y = base.dists.lognormal.stdev( 4.0, 2.0 )\n ~2953.533\n > y = base.dists.lognormal.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.stdev( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.lognormal.variance,"\nbase.dists.lognormal.variance( μ, σ )\n Returns the variance of a lognormal distribution with location `μ` and scale\n `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.lognormal.variance( 0.0, 1.0 )\n ~4.671\n > y = base.dists.lognormal.variance( 4.0, 2.0 )\n ~8723355.729\n > y = base.dists.lognormal.variance( NaN, 1.0 )\n NaN\n > y = base.dists.lognormal.variance( 0.0, NaN )\n NaN\n > y = base.dists.lognormal.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.negativeBinomial.cdf,"\nbase.dists.negativeBinomial.cdf( x, r, p )\n Evaluates the cumulative distribution function (CDF) for a negative binomial\n distribution with number of successes until experiment is stopped `r` and\n success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.negativeBinomial.cdf( 5.0, 20.0, 0.8 )\n ~0.617\n > y = base.dists.negativeBinomial.cdf( 21.0, 20.0, 0.5 )\n ~0.622\n > y = base.dists.negativeBinomial.cdf( 5.0, 10.0, 0.4 )\n ~0.034\n > y = base.dists.negativeBinomial.cdf( 0.0, 10.0, 0.9 )\n ~0.349\n > y = base.dists.negativeBinomial.cdf( 21.0, 15.5, 0.5 )\n ~0.859\n > y = base.dists.negativeBinomial.cdf( 5.0, 7.4, 0.4 )\n ~0.131\n\n > y = base.dists.negativeBinomial.cdf( 2.0, 0.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.cdf( 2.0, -2.0, 0.5 )\n NaN\n\n > y = base.dists.negativeBinomial.cdf( NaN, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.cdf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.cdf( 0.0, 20.0, NaN )\n NaN\n\n > y = base.dists.negativeBinomial.cdf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.negativeBinomial.cdf( 2.0, 20, 1.5 )\n NaN\n\n\nbase.dists.negativeBinomial.cdf.factory( r, p )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a negative binomial distribution with number of successes until\n experiment is stopped `r` and success probability `p`.\n\n Parameters\n ----------\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.negativeBinomial.cdf.factory( 10, 0.5 );\n > var y = myCDF( 3.0 )\n ~0.046\n > y = myCDF( 11.0 )\n ~0.668\n\n"
+base.dists.negativeBinomial.kurtosis,"\nbase.dists.negativeBinomial.kurtosis( r, p )\n Returns the excess kurtosis of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Kurtosis.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.kurtosis( 100, 0.2 )\n ~0.061\n > v = base.dists.negativeBinomial.kurtosis( 20, 0.5 )\n ~0.325\n\n"
+base.dists.negativeBinomial.logpmf,"\nbase.dists.negativeBinomial.logpmf( x, r, p )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n negative binomial distribution with number of successes until experiment is\n stopped `r` and success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.negativeBinomial.logpmf( 5.0, 20.0, 0.8 )\n ~-1.853\n > y = base.dists.negativeBinomial.logpmf( 21.0, 20.0, 0.5 )\n ~-2.818\n > y = base.dists.negativeBinomial.logpmf( 5.0, 10.0, 0.4 )\n ~-4.115\n > y = base.dists.negativeBinomial.logpmf( 0.0, 10.0, 0.9 )\n ~-1.054\n > y = base.dists.negativeBinomial.logpmf( 21.0, 15.5, 0.5 )\n ~-3.292\n > y = base.dists.negativeBinomial.logpmf( 5.0, 7.4, 0.4 )\n ~-2.976\n\n > y = base.dists.negativeBinomial.logpmf( 2.0, 0.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.logpmf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.logpmf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.negativeBinomial.logpmf( 2.0, 20, 1.5 )\n NaN\n\n > y = base.dists.negativeBinomial.logpmf( NaN, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.logpmf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.logpmf( 0.0, 20.0, NaN )\n NaN\n\n\nbase.dists.negativeBinomial.logpmf.factory( r, p )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a negative binomial distribution with number of\n successes until experiment is stopped `r` and success probability `p`.\n\n Parameters\n ----------\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogPMF = base.dists.negativeBinomial.logpmf.factory( 10, 0.5 );\n > var y = mylogPMF( 3.0 )\n ~-3.617\n > y = mylogPMF( 5.0 )\n ~-2.795\n\n"
+base.dists.negativeBinomial.mean,"\nbase.dists.negativeBinomial.mean( r, p )\n Returns the expected value of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.mean( 100, 0.2 )\n 400\n > v = base.dists.negativeBinomial.mean( 20, 0.5 )\n 20\n\n"
+base.dists.negativeBinomial.mgf,"\nbase.dists.negativeBinomial.mgf( x, r, p )\n Evaluates the moment-generating function (MGF) for a negative binomial\n distribution with number of successes until experiment is stopped `r` and\n success probability `p` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.negativeBinomial.mgf( 0.05, 20.0, 0.8 )\n ~267.839\n > y = base.dists.negativeBinomial.mgf( 0.1, 20.0, 0.1 )\n ~9.347\n > y = base.dists.negativeBinomial.mgf( 0.5, 10.0, 0.4 )\n ~42822.023\n\n > y = base.dists.negativeBinomial.mgf( 0.1, 0.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.mgf( 0.1, -2.0, 0.5 )\n NaN\n\n > y = base.dists.negativeBinomial.mgf( NaN, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.mgf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.mgf( 0.0, 20.0, NaN )\n NaN\n\n > y = base.dists.negativeBinomial.mgf( 0.2, 20, -1.0 )\n NaN\n > y = base.dists.negativeBinomial.mgf( 0.2, 20, 1.5 )\n NaN\n\n\nbase.dists.negativeBinomial.mgf.factory( r, p )\n Returns a function for evaluating the moment-generating function (MGF) of a\n negative binomial distribution with number of successes until experiment is\n stopped `r` and success probability `p`.\n\n Parameters\n ----------\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.negativeBinomial.mgf.factory( 4.3, 0.4 );\n > var y = myMGF( 0.2 )\n ~4.696\n > y = myMGF( 0.4 )\n ~30.83\n\n"
+base.dists.negativeBinomial.mode,"\nbase.dists.negativeBinomial.mode( r, p )\n Returns the mode of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.mode( 100, 0.2 )\n 396\n > v = base.dists.negativeBinomial.mode( 20, 0.5 )\n 19\n\n"
+base.dists.negativeBinomial.NegativeBinomial,"\nbase.dists.negativeBinomial.NegativeBinomial( [r, p] )\n Returns a negative binomial distribution object.\n\n Parameters\n ----------\n r: number (optional)\n Number of successes until experiment is stopped. Must be a positive\n number. Default: `1`.\n\n p: number (optional)\n Success probability. Must be a number between `0` and `1`. Default:\n `0.5`.\n\n Returns\n -------\n nbinomial: Object\n Distribution instance.\n\n nbinomial.r: number\n Number of trials. If set, the value must be a positive number.\n\n nbinomial.p: number\n Success probability. If set, the value must be a number between `0` and\n `1`.\n\n nbinomial.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n nbinomial.mean: number\n Read-only property which returns the expected value.\n\n nbinomial.mode: number\n Read-only property which returns the mode.\n\n nbinomial.skewness: number\n Read-only property which returns the skewness.\n\n nbinomial.stdev: number\n Read-only property which returns the standard deviation.\n\n nbinomial.variance: number\n Read-only property which returns the variance.\n\n nbinomial.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n nbinomial.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n nbinomial.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n nbinomial.pmf: Function\n Evaluates the probability mass function (PMF).\n\n nbinomial.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var nbinomial = base.dists.negativeBinomial.NegativeBinomial( 8.0, 0.5 );\n > nbinomial.r\n 8.0\n > nbinomial.p\n 0.5\n > nbinomial.kurtosis\n 0.8125\n > nbinomial.mean\n 8.0\n > nbinomial.mode\n 7.0\n > nbinomial.skewness\n 0.75\n > nbinomial.stdev\n 4.0\n > nbinomial.variance\n 16.0\n > nbinomial.cdf( 2.9 )\n ~0.055\n > nbinomial.logpmf( 3.0 )\n ~-2.837\n > nbinomial.mgf( 0.2 )\n ~36.675\n > nbinomial.pmf( 3.0 )\n ~0.059\n > nbinomial.quantile( 0.8 )\n 11.0\n\n"
+base.dists.negativeBinomial.pmf,"\nbase.dists.negativeBinomial.pmf( x, r, p )\n Evaluates the probability mass function (PMF) for a negative binomial\n distribution with number of successes until experiment is stopped `r` and\n success probability `p` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.negativeBinomial.pmf( 5.0, 20.0, 0.8 )\n ~0.157\n > y = base.dists.negativeBinomial.pmf( 21.0, 20.0, 0.5 )\n ~0.06\n > y = base.dists.negativeBinomial.pmf( 5.0, 10.0, 0.4 )\n ~0.016\n > y = base.dists.negativeBinomial.pmf( 0.0, 10.0, 0.9 )\n ~0.349\n > y = base.dists.negativeBinomial.pmf( 21.0, 15.5, 0.5 )\n ~0.037\n > y = base.dists.negativeBinomial.pmf( 5.0, 7.4, 0.4 )\n ~0.051\n\n > y = base.dists.negativeBinomial.pmf( 2.0, 0.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.pmf( 2.0, -2.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.pmf( 2.0, 20, -1.0 )\n NaN\n > y = base.dists.negativeBinomial.pmf( 2.0, 20, 1.5 )\n NaN\n\n > y = base.dists.negativeBinomial.pmf( NaN, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.pmf( 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.pmf( 0.0, 20.0, NaN )\n NaN\n\n\nbase.dists.negativeBinomial.pmf.factory( r, p )\n Returns a function for evaluating the probability mass function (PMF) of a\n negative binomial distribution with number of successes until experiment is\n stopped `r` and success probability `p`.\n\n Parameters\n ----------\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var myPMF = base.dists.negativeBinomial.pmf.factory( 10, 0.5 );\n > var y = myPMF( 3.0 )\n ~0.027\n > y = myPMF( 5.0 )\n ~0.061\n\n"
+base.dists.negativeBinomial.quantile,"\nbase.dists.negativeBinomial.quantile( k, r, p )\n Evaluates the quantile function for a negative binomial distribution with\n number of successes until experiment is stopped `r` and success probability\n `p` at a probability `k`.\n\n If provided a `k` outside of `[0,1]`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n k: number\n Input probability.\n\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.2 )\n 106\n > y = base.dists.negativeBinomial.quantile( 0.9, 20.0, 0.8 )\n 8\n > y = base.dists.negativeBinomial.quantile( 0.5, 10.0, 0.4 )\n 14\n > y = base.dists.negativeBinomial.quantile( 0.0, 10.0, 0.9 )\n 0\n\n > y = base.dists.negativeBinomial.quantile( 1.1, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.quantile( -0.1, 20.0, 0.5 )\n NaN\n\n > y = base.dists.negativeBinomial.quantile( 21.0, 15.5, 0.5 )\n 12\n > y = base.dists.negativeBinomial.quantile( 5.0, 7.4, 0.4 )\n 10\n\n > y = base.dists.negativeBinomial.quantile( 0.5, 0.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.quantile( 0.5, -2.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.quantile( 0.3, 20.0, -1.0 )\n NaN\n > y = base.dists.negativeBinomial.quantile( 0.3, 20.0, 1.5 )\n NaN\n\n > y = base.dists.negativeBinomial.quantile( NaN, 20.0, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.quantile( 0.3, NaN, 0.5 )\n NaN\n > y = base.dists.negativeBinomial.quantile( 0.3, 20.0, NaN )\n NaN\n\n\nbase.dists.negativeBinomial.quantile.factory( r, p )\n Returns a function for evaluating the quantile function of a negative\n binomial distribution with number of successes until experiment is stopped\n `r` and success probability `p`.\n\n Parameters\n ----------\n r: number\n Number of successes until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.negativeBinomial.quantile.factory( 10.0, 0.5 );\n > var y = myQuantile( 0.1 )\n 5\n > y = myQuantile( 0.9 )\n 16\n\n"
+base.dists.negativeBinomial.skewness,"\nbase.dists.negativeBinomial.skewness( r, p )\n Returns the skewness of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.skewness( 100, 0.2 )\n ~0.201\n > v = base.dists.negativeBinomial.skewness( 20, 0.5 )\n ~0.474\n\n"
+base.dists.negativeBinomial.stdev,"\nbase.dists.negativeBinomial.stdev( r, p )\n Returns the standard deviation of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.stdev( 100, 0.2 )\n ~44.721\n > v = base.dists.negativeBinomial.stdev( 20, 0.5 )\n ~6.325\n\n"
+base.dists.negativeBinomial.variance,"\nbase.dists.negativeBinomial.variance( r, p )\n Returns the variance of a negative binomial distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a `r` which is not a positive number, the function returns\n `NaN`.\n\n If provided a success probability `p` outside of `[0,1]`, the function\n returns `NaN`.\n\n Parameters\n ----------\n r: integer\n Number of failures until experiment is stopped.\n\n p: number\n Success probability.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.negativeBinomial.variance( 100, 0.2 )\n 2000.0\n > v = base.dists.negativeBinomial.variance( 20, 0.5 )\n 40.0\n\n"
+base.dists.normal.cdf,"\nbase.dists.normal.cdf( x, μ, σ )\n Evaluates the cumulative distribution function (CDF) for a normal\n distribution with mean `μ` and standard deviation `σ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.normal.cdf( 2.0, 0.0, 1.0 )\n ~0.977\n > y = base.dists.normal.cdf( -1.0, -1.0, 2.0 )\n 0.5\n > y = base.dists.normal.cdf( -1.0, 4.0, 2.0 )\n ~0.006\n > y = base.dists.normal.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.normal.cdf( 0.0, 0.0, NaN )\n NaN\n\n // Negative standard deviation:\n > y = base.dists.normal.cdf( 2.0, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `σ = 0.0`:\n > y = base.dists.normal.cdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.normal.cdf( 8.0, 8.0, 0.0 )\n 1.0\n > y = base.dists.normal.cdf( 10.0, 8.0, 0.0 )\n 1.0\n\n\nbase.dists.normal.cdf.factory( μ, σ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a normal distribution with mean `μ` and standard deviation `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.normal.cdf.factory( 10.0, 2.0 );\n > var y = myCDF( 10.0 )\n 0.5\n\n"
+base.dists.normal.entropy,"\nbase.dists.normal.entropy( μ, σ )\n Returns the differential entropy of a normal distribution with mean `μ` and\n standard deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var y = base.dists.normal.entropy( 0.0, 1.0 )\n ~1.419\n > y = base.dists.normal.entropy( 4.0, 3.0 )\n ~2.518\n > y = base.dists.normal.entropy( NaN, 1.0 )\n NaN\n > y = base.dists.normal.entropy( 0.0, NaN )\n NaN\n > y = base.dists.normal.entropy( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.kurtosis,"\nbase.dists.normal.kurtosis( μ, σ )\n Returns the excess kurtosis of a normal distribution with mean `μ` and\n standard deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var y = base.dists.normal.kurtosis( 0.0, 1.0 )\n 0.0\n > y = base.dists.normal.kurtosis( 4.0, 3.0 )\n 0.0\n > y = base.dists.normal.kurtosis( NaN, 1.0 )\n NaN\n > y = base.dists.normal.kurtosis( 0.0, NaN )\n NaN\n > y = base.dists.normal.kurtosis( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.logpdf,"\nbase.dists.normal.logpdf( x, μ, σ )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a normal distribution with mean `μ` and standard deviation `σ` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.normal.logpdf( 2.0, 0.0, 1.0 )\n ~-2.919\n > y = base.dists.normal.logpdf( -1.0, 4.0, 2.0 )\n ~-4.737\n > y = base.dists.normal.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.normal.logpdf( 0.0, 0.0, NaN )\n NaN\n\n // Negative standard deviation:\n > y = base.dists.normal.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `σ = 0.0`:\n > y = base.dists.normal.logpdf( 2.0, 8.0, 0.0 )\n -Infinity\n > y = base.dists.normal.logpdf( 8.0, 8.0, 0.0 )\n Infinity\n\n\nbase.dists.normal.logpdf.factory( μ, σ )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a normal distribution with mean `μ` and standard\n deviation `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var myLogPDF = base.dists.normal.logpdf.factory( 10.0, 2.0 );\n > var y = myLogPDF( 10.0 )\n ~-1.612\n\n"
+base.dists.normal.mean,"\nbase.dists.normal.mean( μ, σ )\n Returns the expected value of a normal distribution with mean `μ` and\n standard deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var y = base.dists.normal.mean( 0.0, 1.0 )\n 0.0\n > y = base.dists.normal.mean( 4.0, 2.0 )\n 4.0\n > y = base.dists.normal.mean( NaN, 1.0 )\n NaN\n > y = base.dists.normal.mean( 0.0, NaN )\n NaN\n > y = base.dists.normal.mean( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.median,"\nbase.dists.normal.median( μ, σ )\n Returns the median of a normal distribution with mean `μ` and standard\n deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var y = base.dists.normal.median( 0.0, 1.0 )\n 0.0\n > y = base.dists.normal.median( 4.0, 2.0 )\n 4.0\n > y = base.dists.normal.median( NaN, 1.0 )\n NaN\n > y = base.dists.normal.median( 0.0, NaN )\n NaN\n > y = base.dists.normal.median( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.mgf,"\nbase.dists.normal.mgf( x, μ, σ )\n Evaluates the moment-generating function (MGF) for a normal distribution\n with mean `μ` and standard deviation `σ` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.normal.mgf( 2.0, 0.0, 1.0 )\n ~7.389\n > y = base.dists.normal.mgf( 0.0, 0.0, 1.0 )\n 1.0\n > y = base.dists.normal.mgf( -1.0, 4.0, 2.0 )\n ~0.1353\n > y = base.dists.normal.mgf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.normal.mgf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.normal.mgf( 2.0, 0.0, 0.0 )\n NaN\n\n\nbase.dists.normal.mgf.factory( μ, σ )\n Returns a function for evaluating the moment-generating function (MGF) of a\n normal distribution with mean `μ` and standard deviation `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.normal.mgf.factory( 4.0, 2.0 );\n > var y = myMGF( 1.0 )\n ~403.429\n > y = myMGF( 0.5 )\n ~12.182\n\n"
+base.dists.normal.mode,"\nbase.dists.normal.mode( μ, σ )\n Returns the mode of a normal distribution with mean `μ` and standard\n deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var y = base.dists.normal.mode( 0.0, 1.0 )\n 0.0\n > y = base.dists.normal.mode( 4.0, 2.0 )\n 4.0\n > y = base.dists.normal.mode( NaN, 1.0 )\n NaN\n > y = base.dists.normal.mode( 0.0, NaN )\n NaN\n > y = base.dists.normal.mode( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.Normal,"\nbase.dists.normal.Normal( [μ, σ] )\n Returns a normal distribution object.\n\n Parameters\n ----------\n μ: number (optional)\n Mean parameter. Default: `0.0`.\n\n σ: number (optional)\n Standard deviation. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n normal: Object\n Distribution instance.\n\n normal.mu: number\n Mean parameter.\n\n normal.sigma: number\n Standard deviation. If set, the value must be greater than `0`.\n\n normal.entropy: number\n Read-only property which returns the differential entropy.\n\n normal.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n normal.mean: number\n Read-only property which returns the expected value.\n\n normal.median: number\n Read-only property which returns the median.\n\n normal.mode: number\n Read-only property which returns the mode.\n\n normal.skewness: number\n Read-only property which returns the skewness.\n\n normal.stdev: number\n Read-only property which returns the standard deviation.\n\n normal.variance: number\n Read-only property which returns the variance.\n\n normal.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n normal.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n normal.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n normal.pdf: Function\n Evaluates the probability density function (PDF).\n\n normal.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var normal = base.dists.normal.Normal( -2.0, 3.0 );\n > normal.mu\n -2.0\n > normal.sigma\n 3.0\n > normal.entropy\n ~2.518\n > normal.kurtosis\n 0.0\n > normal.mean\n -2.0\n > normal.median\n -2.0\n > normal.mode\n -2.0\n > normal.skewness\n 0.0\n > normal.stdev\n 3.0\n > normal.variance\n 9.0\n > normal.cdf( 0.8 )\n ~0.825\n > normal.logpdf( 2.0 )\n ~-2.9\n > normal.mgf( 0.2 )\n ~0.803\n > normal.pdf( 2.0 )\n ~0.055\n > normal.quantile( 0.9 )\n ~1.845\n\n"
+base.dists.normal.pdf,"\nbase.dists.normal.pdf( x, μ, σ )\n Evaluates the probability density function (PDF) for a normal distribution\n with mean `μ` and standard deviation `σ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.normal.pdf( 2.0, 0.0, 1.0 )\n ~0.054\n > y = base.dists.normal.pdf( -1.0, 4.0, 2.0 )\n ~0.009\n > y = base.dists.normal.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.normal.pdf( 0.0, 0.0, NaN )\n NaN\n\n // Negative standard deviation:\n > y = base.dists.normal.pdf( 2.0, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `σ = 0.0`:\n > y = base.dists.normal.pdf( 2.0, 8.0, 0.0 )\n 0.0\n > y = base.dists.normal.pdf( 8.0, 8.0, 0.0 )\n infinity\n\n\nbase.dists.normal.pdf.factory( μ, σ )\n Returns a function for evaluating the probability density function (PDF) of\n a normal distribution with mean `μ` and standard deviation `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.normal.pdf.factory( 10.0, 2.0 );\n > var y = myPDF( 10.0 )\n ~0.199\n\n"
+base.dists.normal.quantile,"\nbase.dists.normal.quantile( p, μ, σ )\n Evaluates the quantile function for a normal distribution with mean `μ` and\n standard deviation `σ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.normal.quantile( 0.8, 0.0, 1.0 )\n ~0.842\n > y = base.dists.normal.quantile( 0.5, 4.0, 2.0 )\n 4\n\n > y = base.dists.normal.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.normal.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.normal.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.normal.quantile( 0.0, 0.0, NaN )\n NaN\n\n // Negative standard deviation:\n > y = base.dists.normal.quantile( 0.5, 0.0, -1.0 )\n NaN\n\n // Degenerate distribution centered at `μ` when `σ = 0.0`:\n > y = base.dists.normal.quantile( 0.3, 8.0, 0.0 )\n 8.0\n > y = base.dists.normal.quantile( 0.9, 8.0, 0.0 )\n 8.0\n\n\nbase.dists.normal.quantile.factory( μ, σ )\n Returns a function for evaluating the quantile function\n of a normal distribution with mean `μ` and standard deviation `σ`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.normal.quantile.factory( 10.0, 2.0 );\n > var y = myQuantile( 0.5 )\n 10.0\n\n"
+base.dists.normal.skewness,"\nbase.dists.normal.skewness( μ, σ )\n Returns the skewness of a normal distribution with mean `μ` and standard\n deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var y = base.dists.normal.skewness( 0.0, 1.0 )\n 0.0\n > y = base.dists.normal.skewness( 4.0, 3.0 )\n 0.0\n > y = base.dists.normal.skewness( NaN, 1.0 )\n NaN\n > y = base.dists.normal.skewness( 0.0, NaN )\n NaN\n > y = base.dists.normal.skewness( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.stdev,"\nbase.dists.normal.stdev( μ, σ )\n Returns the standard deviation of a normal distribution with mean `μ` and\n standard deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var y = base.dists.normal.stdev( 0.0, 1.0 )\n 1.0\n > y = base.dists.normal.stdev( 4.0, 3.0 )\n 3.0\n > y = base.dists.normal.stdev( NaN, 1.0 )\n NaN\n > y = base.dists.normal.stdev( 0.0, NaN )\n NaN\n > y = base.dists.normal.stdev( 0.0, 0.0 )\n NaN\n\n"
+base.dists.normal.variance,"\nbase.dists.normal.variance( μ, σ )\n Returns the variance of a normal distribution with mean `μ` and standard\n deviation `σ`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n σ: number\n Standard deviation.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var y = base.dists.normal.variance( 0.0, 1.0 )\n 1.0\n > y = base.dists.normal.variance( 4.0, 3.0 )\n 9.0\n > y = base.dists.normal.variance( NaN, 1.0 )\n NaN\n > y = base.dists.normal.variance( 0.0, NaN )\n NaN\n > y = base.dists.normal.variance( 0.0, 0.0 )\n NaN\n\n"
+base.dists.pareto1.cdf,"\nbase.dists.pareto1.cdf( x, α, β )\n Evaluates the cumulative distribution function (CDF) for a Pareto (Type I)\n distribution with shape parameter `α` and scale parameter `β` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.pareto1.cdf( 2.0, 1.0, 1.0 )\n 0.5\n > y = base.dists.pareto1.cdf( 5.0, 2.0, 4.0 )\n ~0.36\n > y = base.dists.pareto1.cdf( 4.0, 2.0, 2.0 )\n 0.75\n > y = base.dists.pareto1.cdf( 1.9, 2.0, 2.0 )\n 0.0\n > y = base.dists.pareto1.cdf( PINF, 4.0, 2.0 )\n 1.0\n\n > y = base.dists.pareto1.cdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.pareto1.cdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.pareto1.cdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.pareto1.cdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.pareto1.cdf.factory( α, β )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Pareto (Type I) distribution with shape parameter `α` and scale\n parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.pareto1.cdf.factory( 10.0, 2.0 );\n > var y = myCDF( 3.0 )\n ~0.983\n > y = myCDF( 2.5 )\n ~0.893\n\n"
+base.dists.pareto1.entropy,"\nbase.dists.pareto1.entropy( α, β )\n Returns the differential entropy of a Pareto (Type I) distribution\n (in nats).\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Differential entropy.\n\n Examples\n --------\n > var v = base.dists.pareto1.entropy( 0.8, 1.0 )\n ~2.473\n > v = base.dists.pareto1.entropy( 4.0, 12.0 )\n ~2.349\n > v = base.dists.pareto1.entropy( 8.0, 2.0 )\n ~-0.261\n\n"
+base.dists.pareto1.kurtosis,"\nbase.dists.pareto1.kurtosis( α, β )\n Returns the excess kurtosis of a Pareto (Type I) distribution.\n\n If `α <= 4` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.pareto1.kurtosis( 5.0, 1.0 )\n ~70.8\n > v = base.dists.pareto1.kurtosis( 4.5, 12.0 )\n ~146.444\n > v = base.dists.pareto1.kurtosis( 8.0, 2.0 )\n ~19.725\n\n"
+base.dists.pareto1.logcdf,"\nbase.dists.pareto1.logcdf( x, α, β )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a Pareto (Type I) distribution with shape parameter `α` and scale\n parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.pareto1.logcdf( 2.0, 1.0, 1.0 )\n ~-0.693\n > y = base.dists.pareto1.logcdf( 5.0, 2.0, 4.0 )\n ~-1.022\n > y = base.dists.pareto1.logcdf( 4.0, 2.0, 2.0 )\n ~-0.288\n > y = base.dists.pareto1.logcdf( 1.9, 2.0, 2.0 )\n -Infinity\n > y = base.dists.pareto1.logcdf( PINF, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.pareto1.logcdf( 2.0, -1.0, 0.5 )\n NaN\n > y = base.dists.pareto1.logcdf( 2.0, 0.5, -1.0 )\n NaN\n\n > y = base.dists.pareto1.logcdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.pareto1.logcdf( 0.0, 1.0, NaN )\n NaN\n\n\nbase.dists.pareto1.logcdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a Pareto (Type I) distribution with shape\n parameter `α` and scale parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogCDF = base.dists.pareto1.logcdf.factory( 10.0, 2.0 );\n > var y = mylogCDF( 3.0 )\n ~-0.017\n > y = mylogCDF( 2.5 )\n ~-0.114\n\n"
+base.dists.pareto1.logpdf,"\nbase.dists.pareto1.logpdf( x, α, β )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a Pareto (Type I) distribution with shape parameter `α` and scale\n parameter `β` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.pareto1.logpdf( 4.0, 1.0, 1.0 )\n ~-2.773\n > y = base.dists.pareto1.logpdf( 20.0, 1.0, 10.0 )\n ~-3.689\n > y = base.dists.pareto1.logpdf( 7.0, 2.0, 6.0 )\n ~-1.561\n > y = base.dists.pareto1.logpdf( 7.0, 6.0, 3.0 )\n ~-5.238\n > y = base.dists.pareto1.logpdf( 1.0, 4.0, 2.0 )\n -Infinity\n > y = base.dists.pareto1.logpdf( 1.5, 4.0, 2.0 )\n -Infinity\n\n > y = base.dists.pareto1.logpdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.pareto1.logpdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.pareto1.logpdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.logpdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.pareto1.logpdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.pareto1.logpdf.factory( α, β )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a Pareto (Type I) distribution with shape\n parameter `α` and scale parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.pareto1.logpdf.factory( 0.5, 0.5 );\n > var y = mylogPDF( 0.8 )\n ~-0.705\n > y = mylogPDF( 2.0 )\n ~-2.079\n\n"
+base.dists.pareto1.mean,"\nbase.dists.pareto1.mean( α, β )\n Returns the expected value of a Pareto (Type I) distribution.\n\n If `0 < α <= 1`, the function returns `Infinity`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.pareto1.mean( 0.8, 1.0 )\n Infinity\n > v = base.dists.pareto1.mean( 4.0, 12.0 )\n 16.0\n > v = base.dists.pareto1.mean( 8.0, 2.0 )\n ~2.286\n\n"
+base.dists.pareto1.median,"\nbase.dists.pareto1.median( α, β )\n Returns the median of a Pareto (Type I) distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.pareto1.median( 0.8, 1.0 )\n ~2.378\n > v = base.dists.pareto1.median( 4.0, 12.0 )\n ~14.27\n > v = base.dists.pareto1.median( 8.0, 2.0 )\n ~2.181\n\n"
+base.dists.pareto1.mode,"\nbase.dists.pareto1.mode( α, β )\n Returns the mode of a Pareto (Type I) distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.pareto1.mode( 0.8, 1.0 )\n 1.0\n > v = base.dists.pareto1.mode( 4.0, 12.0 )\n 12.0\n > v = base.dists.pareto1.mode( 8.0, 2.0 )\n 2.0\n\n"
+base.dists.pareto1.Pareto1,"\nbase.dists.pareto1.Pareto1( [α, β] )\n Returns a Pareto (Type I) distribution object.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter. Must be greater than `0`. Default: `1.0`.\n\n β: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n pareto1: Object\n Distribution instance.\n\n pareto1.alpha: number\n Shape parameter. If set, the value must be greater than `0`.\n\n pareto1.beta: number\n Scale parameter. If set, the value must be greater than `0`.\n\n pareto1.entropy: number\n Read-only property which returns the differential entropy.\n\n pareto1.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n pareto1.mean: number\n Read-only property which returns the expected value.\n\n pareto1.median: number\n Read-only property which returns the median.\n\n pareto1.mode: number\n Read-only property which returns the mode.\n\n pareto1.skewness: number\n Read-only property which returns the skewness.\n\n pareto1.variance: number\n Read-only property which returns the variance.\n\n pareto1.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n pareto1.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (logCDF).\n\n pareto1.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (logPDF).\n\n pareto1.pdf: Function\n Evaluates the probability density function (PDF).\n\n pareto1.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var pareto1 = base.dists.pareto1.Pareto1( 6.0, 5.0 );\n > pareto1.alpha\n 6.0\n > pareto1.beta\n 5.0\n > pareto1.entropy\n ~0.984\n > pareto1.kurtosis\n ~35.667\n > pareto1.mean\n 6.0\n > pareto1.median\n ~5.612\n > pareto1.mode\n 5.0\n > pareto1.skewness\n ~3.81\n > pareto1.variance\n 1.5\n > pareto1.cdf( 7.0 )\n ~0.867\n > pareto1.logcdf( 7.0 )\n ~-0.142\n > pareto1.logpdf( 5.0 )\n ~0.182\n > pareto1.pdf( 5.0 )\n 1.2\n > pareto1.quantile( 0.8 )\n ~6.538\n\n"
+base.dists.pareto1.pdf,"\nbase.dists.pareto1.pdf( x, α, β )\n Evaluates the probability density function (PDF) for a Pareto (Type I)\n distribution with shape parameter `α` and scale parameter `β` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.pareto1.pdf( 4.0, 1.0, 1.0 )\n ~0.063\n > y = base.dists.pareto1.pdf( 20.0, 1.0, 10.0 )\n 0.025\n > y = base.dists.pareto1.pdf( 7.0, 2.0, 6.0 )\n ~0.21\n > y = base.dists.pareto1.pdf( 7.0, 6.0, 3.0 )\n ~0.005\n > y = base.dists.pareto1.pdf( 1.0, 4.0, 2.0 )\n 0.0\n > y = base.dists.pareto1.pdf( 1.5, 4.0, 2.0 )\n 0.0\n\n > y = base.dists.pareto1.pdf( 0.5, -1.0, 0.5 )\n NaN\n > y = base.dists.pareto1.pdf( 0.5, 0.5, -1.0 )\n NaN\n\n > y = base.dists.pareto1.pdf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.pdf( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.pareto1.pdf( 0.5, 1.0, NaN )\n NaN\n\n\nbase.dists.pareto1.pdf.factory( α, β )\n Returns a function for evaluating the probability density function (PDF) of\n a Pareto (Type I) distribution with shape parameter `α` and scale parameter\n `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.pareto1.pdf.factory( 0.5, 0.5 );\n > var y = myPDF( 0.8 )\n ~0.494\n > y = myPDF( 2.0 )\n ~0.125\n\n"
+base.dists.pareto1.quantile,"\nbase.dists.pareto1.quantile( p, α, β )\n Evaluates the quantile function for a Pareto (Type I) distribution with\n shape parameter `α` and scale parameter `β` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.pareto1.quantile( 0.8, 2.0, 1.0 )\n ~2.236\n > y = base.dists.pareto1.quantile( 0.8, 1.0, 10.0 )\n ~50.0\n > y = base.dists.pareto1.quantile( 0.1, 1.0, 10.0 )\n ~11.111\n\n > y = base.dists.pareto1.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.pareto1.quantile( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.quantile( 0.5, NaN, 1.0 )\n NaN\n > y = base.dists.pareto1.quantile( 0.5, 1.0, NaN )\n NaN\n\n > y = base.dists.pareto1.quantile( 0.5, -1.0, 1.0 )\n NaN\n > y = base.dists.pareto1.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.pareto1.quantile.factory( α, β )\n Returns a function for evaluating the quantile function of a Pareto (Type I)\n distribution with shape parameter `α` and scale parameter `β`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.pareto1.quantile.factory( 2.5, 0.5 );\n > var y = myQuantile( 0.5 )\n ~0.66\n > y = myQuantile( 0.8 )\n ~0.952\n\n"
+base.dists.pareto1.skewness,"\nbase.dists.pareto1.skewness( α, β )\n Returns the skewness of a Pareto (Type I) distribution.\n\n If `α <= 3` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.pareto1.skewness( 3.5, 1.0 )\n ~11.784\n > v = base.dists.pareto1.skewness( 4.0, 12.0 )\n ~7.071\n > v = base.dists.pareto1.skewness( 8.0, 2.0 )\n ~3.118\n\n"
+base.dists.pareto1.variance,"\nbase.dists.pareto1.variance( α, β )\n Returns the variance of a Pareto (Type I) distribution.\n\n If `0 < α <= 2` and `β > 0`, the function returns positive infinity.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.pareto1.variance( 0.8, 1.0 )\n Infinity\n > v = base.dists.pareto1.variance( 4.0, 12.0 )\n 32.0\n > v = base.dists.pareto1.variance( 8.0, 2.0 )\n ~0.109\n\n"
+base.dists.poisson.cdf,"\nbase.dists.poisson.cdf( x, λ )\n Evaluates the cumulative distribution function (CDF) for a Poisson\n distribution with mean parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.poisson.cdf( 2.0, 0.5 )\n ~0.986\n > y = base.dists.poisson.cdf( 2.0, 10.0 )\n ~0.003\n > y = base.dists.poisson.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.poisson.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.poisson.cdf( 0.0, NaN )\n NaN\n\n // Negative mean parameter:\n > y = base.dists.poisson.cdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution at `λ = 0`:\n > y = base.dists.poisson.cdf( -2.0, 0.0 )\n 0.0\n > y = base.dists.poisson.cdf( 0.0, 0.0 )\n 1.0\n > y = base.dists.poisson.cdf( 10.0, 0.0 )\n 1.0\n\n\nbase.dists.poisson.cdf.factory( λ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Poisson distribution with mean parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.poisson.cdf.factory( 5.0 );\n > var y = mycdf( 3.0 )\n ~0.265\n > y = mycdf( 8.0 )\n ~0.932\n\n"
+base.dists.poisson.entropy,"\nbase.dists.poisson.entropy( λ )\n Returns the entropy of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.poisson.entropy( 11.0 )\n ~2.61\n > v = base.dists.poisson.entropy( 4.5 )\n ~2.149\n\n"
+base.dists.poisson.kurtosis,"\nbase.dists.poisson.kurtosis( λ )\n Returns the excess kurtosis of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.poisson.kurtosis( 11.0 )\n ~0.091\n > v = base.dists.poisson.kurtosis( 4.5 )\n ~0.222\n\n"
+base.dists.poisson.logpmf,"\nbase.dists.poisson.logpmf( x, λ )\n Evaluates the natural logarithm of the probability mass function (PMF) for a\n Poisson distribution with mean parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Evaluated logPMF.\n\n Examples\n --------\n > var y = base.dists.poisson.logpmf( 4.0, 3.0 )\n ~-1.784\n > y = base.dists.poisson.logpmf( 1.0, 3.0 )\n ~-1.901\n > y = base.dists.poisson.logpmf( -1.0, 2.0 )\n -Infinity\n > y = base.dists.poisson.logpmf( 0.0, NaN )\n NaN\n > y = base.dists.poisson.logpmf( NaN, 0.5 )\n NaN\n\n // Negative mean parameter:\n > y = base.dists.poisson.logpmf( 2.0, -0.5 )\n NaN\n\n // Degenerate distribution at `λ = 0`:\n > y = base.dists.poisson.logpmf( 2.0, 0.0 )\n -Infinity\n > y = base.dists.poisson.logpmf( 0.0, 0.0 )\n 0.0\n\n\nbase.dists.poisson.logpmf.factory( λ )\n Returns a function for evaluating the natural logarithm of the probability\n mass function (PMF) of a Poisson distribution with mean parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n logpmf: Function\n Logarithm of probability mass function (PMF).\n\n Examples\n --------\n > var mylogpmf = base.dists.poisson.logpmf.factory( 1.0 );\n > var y = mylogpmf( 3.0 )\n ~-2.792\n > y = mylogpmf( 1.0 )\n ~-1.0\n\n"
+base.dists.poisson.mean,"\nbase.dists.poisson.mean( λ )\n Returns the expected value of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.poisson.mean( 11.0 )\n 11.0\n > v = base.dists.poisson.mean( 4.5 )\n 4.5\n\n"
+base.dists.poisson.median,"\nbase.dists.poisson.median( λ )\n Returns the median of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: integer\n Median.\n\n Examples\n --------\n > var v = base.dists.poisson.median( 11.0 )\n 11\n > v = base.dists.poisson.median( 4.5 )\n 4\n\n"
+base.dists.poisson.mode,"\nbase.dists.poisson.mode( λ )\n Returns the mode of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: integer\n Mode.\n\n Examples\n --------\n > var v = base.dists.poisson.mode( 11.0 )\n 11\n > v = base.dists.poisson.mode( 4.5 )\n 4\n\n"
+base.dists.poisson.pmf,"\nbase.dists.poisson.pmf( x, λ )\n Evaluates the probability mass function (PMF) for a Poisson\n distribution with mean parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Evaluated PMF.\n\n Examples\n --------\n > var y = base.dists.poisson.pmf( 4.0, 3.0 )\n ~0.168\n > y = base.dists.poisson.pmf( 1.0, 3.0 )\n ~0.149\n > y = base.dists.poisson.pmf( -1.0, 2.0 )\n 0.0\n > y = base.dists.poisson.pmf( 0.0, NaN )\n NaN\n > y = base.dists.poisson.pmf( NaN, 0.5 )\n NaN\n\n // Negative mean parameter:\n > y = base.dists.poisson.pmf( 2.0, -0.5 )\n NaN\n\n // Degenerate distribution at `λ = 0`:\n > y = base.dists.poisson.pmf( 2.0, 0.0 )\n 0.0\n > y = base.dists.poisson.pmf( 0.0, 0.0 )\n 1.0\n\n\nbase.dists.poisson.pmf.factory( λ )\n Returns a function for evaluating the probability mass function (PMF)\n of a Poisson distribution with mean parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n pmf: Function\n Probability mass function (PMF).\n\n Examples\n --------\n > var mypmf = base.dists.poisson.pmf.factory( 1.0 );\n > var y = mypmf( 3.0 )\n ~0.061\n > y = mypmf( 1.0 )\n ~0.368\n\n"
+base.dists.poisson.Poisson,"\nbase.dists.poisson.Poisson( [λ] )\n Returns a Poisson distribution object.\n\n Parameters\n ----------\n λ: number (optional)\n Mean parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n poisson: Object\n Distribution instance.\n\n poisson.lambda: number\n Mean parameter. If set, the value must be greater than `0`.\n\n poisson.entropy: number\n Read-only property which returns the differential entropy.\n\n poisson.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n poisson.mean: number\n Read-only property which returns the expected value.\n\n poisson.median: number\n Read-only property which returns the median.\n\n poisson.mode: number\n Read-only property which returns the mode.\n\n poisson.skewness: number\n Read-only property which returns the skewness.\n\n poisson.stdev: number\n Read-only property which returns the standard deviation.\n\n poisson.variance: number\n Read-only property which returns the variance.\n\n poisson.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n poisson.logpmf: Function\n Evaluates the natural logarithm of the probability mass function (PMF).\n\n poisson.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n poisson.pmf: Function\n Evaluates the probability mass function (PMF).\n\n poisson.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var poisson = base.dists.poisson.Poisson( 6.0 );\n > poisson.lambda\n 6.0\n > poisson.entropy\n ~2.3\n > poisson.kurtosis\n ~0.167\n > poisson.mean\n 6.0\n > poisson.median\n 6.0\n > poisson.mode\n 6.0\n > poisson.skewness\n ~0.408\n > poisson.stdev\n ~2.449\n > poisson.variance\n 6.0\n > poisson.cdf( 4.0 )\n ~0.285\n > poisson.logpmf( 2.0 )\n ~-3.11\n > poisson.mgf( 0.5 )\n ~49.025\n > poisson.pmf( 2.0 )\n ~0.045\n > poisson.quantile( 0.5 )\n 6.0\n\n"
+base.dists.poisson.quantile,"\nbase.dists.poisson.quantile( p, λ )\n Evaluates the quantile function for a Poisson distribution with mean\n parameter `λ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.poisson.quantile( 0.5, 2.0 )\n 2\n > y = base.dists.poisson.quantile( 0.9, 4.0 )\n 7\n > y = base.dists.poisson.quantile( 0.1, 200.0 )\n 182\n\n > y = base.dists.poisson.quantile( 1.1, 0.0 )\n NaN\n > y = base.dists.poisson.quantile( -0.2, 0.0 )\n NaN\n\n > y = base.dists.poisson.quantile( NaN, 0.5 )\n NaN\n > y = base.dists.poisson.quantile( 0.0, NaN )\n NaN\n\n // Negative mean parameter:\n > y = base.dists.poisson.quantile( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution at `λ = 0`:\n > y = base.dists.poisson.quantile( 0.1, 0.0 )\n 0.0\n > y = base.dists.poisson.quantile( 0.9, 0.0 )\n 0.0\n\n\nbase.dists.poisson.quantile.factory( λ )\n Returns a function for evaluating the quantile function of a Poisson\n distribution with mean parameter `λ`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.poisson.quantile.factory( 0.4 );\n > var y = myQuantile( 0.4 )\n 0.0\n > y = myQuantile( 1.0 )\n Infinity\n\n"
+base.dists.poisson.skewness,"\nbase.dists.poisson.skewness( λ )\n Returns the skewness of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a nonpositive value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.poisson.skewness( 11.0 )\n ~0.302\n > v = base.dists.poisson.skewness( 4.5 )\n ~0.471\n\n"
+base.dists.poisson.stdev,"\nbase.dists.poisson.stdev( λ )\n Returns the standard deviation of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.poisson.stdev( 11.0 )\n ~3.317\n > v = base.dists.poisson.stdev( 4.5 )\n ~2.121\n\n"
+base.dists.poisson.variance,"\nbase.dists.poisson.variance( λ )\n Returns the variance of a Poisson distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `λ`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Mean parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.poisson.variance( 11.0 )\n 11.0\n > v = base.dists.poisson.variance( 4.5 )\n 4.5\n\n"
+base.dists.rayleigh.cdf,"\nbase.dists.rayleigh.cdf( x, sigma )\n Evaluates the cumulative distribution function (CDF) for a Rayleigh\n distribution with scale parameter `sigma` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.rayleigh.cdf( 2.0, 3.0 )\n ~0.199\n > y = base.dists.rayleigh.cdf( 1.0, 2.0 )\n ~0.118\n > y = base.dists.rayleigh.cdf( -1.0, 4.0 )\n 0.0\n > y = base.dists.rayleigh.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.rayleigh.cdf( 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.rayleigh.cdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `sigma = 0.0`:\n > y = base.dists.rayleigh.cdf( -2.0, 0.0 )\n 0.0\n > y = base.dists.rayleigh.cdf( 0.0, 0.0 )\n 1.0\n > y = base.dists.rayleigh.cdf( 2.0, 0.0 )\n 1.0\n\n\nbase.dists.rayleigh.cdf.factory( sigma )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Rayleigh distribution with scale parameter `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.rayleigh.cdf.factory( 0.5 );\n > var y = myCDF( 1.0 )\n ~0.865\n > y = myCDF( 0.5 )\n ~0.393\n\n"
+base.dists.rayleigh.entropy,"\nbase.dists.rayleigh.entropy( σ )\n Returns the differential entropy of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.rayleigh.entropy( 11.0 )\n ~3.34\n > v = base.dists.rayleigh.entropy( 4.5 )\n ~2.446\n\n"
+base.dists.rayleigh.kurtosis,"\nbase.dists.rayleigh.kurtosis( σ )\n Returns the excess kurtosis of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.rayleigh.kurtosis( 11.0 )\n ~0.245\n > v = base.dists.rayleigh.kurtosis( 4.5 )\n ~0.245\n\n"
+base.dists.rayleigh.logcdf,"\nbase.dists.rayleigh.logcdf( x, sigma )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n Rayleigh distribution with scale parameter `sigma` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.rayleigh.logcdf( 2.0, 3.0 )\n ~-1.613\n > y = base.dists.rayleigh.logcdf( 1.0, 2.0 )\n ~-2.141\n > y = base.dists.rayleigh.logcdf( -1.0, 4.0 )\n -Infinity\n > y = base.dists.rayleigh.logcdf( NaN, 1.0 )\n NaN\n > y = base.dists.rayleigh.logcdf( 0.0, NaN )\n NaN\n // Negative scale parameter:\n > y = base.dists.rayleigh.logcdf( 2.0, -1.0 )\n NaN\n\n\nbase.dists.rayleigh.logcdf.factory( sigma )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Rayleigh distribution with scale parameter\n `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.rayleigh.logcdf.factory( 0.5 );\n > var y = mylogcdf( 1.0 )\n ~-0.145\n > y = mylogcdf( 0.5 )\n ~-0.933\n\n"
+base.dists.rayleigh.logpdf,"\nbase.dists.rayleigh.logpdf( x, sigma )\n Evaluates the logarithm of the probability density function (PDF) for a\n Rayleigh distribution with scale parameter `sigma` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.rayleigh.logpdf( 0.3, 1.0 )\n ~-1.249\n > y = base.dists.rayleigh.logpdf( 2.0, 0.8 )\n ~-1.986\n > y = base.dists.rayleigh.logpdf( -1.0, 0.5 )\n -Infinity\n > y = base.dists.rayleigh.logpdf( 0.0, NaN )\n NaN\n > y = base.dists.rayleigh.logpdf( NaN, 2.0 )\n NaN\n // Negative scale parameter:\n > y = base.dists.rayleigh.logpdf( 2.0, -1.0 )\n NaN\n\n\nbase.dists.rayleigh.logpdf.factory( sigma )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Rayleigh distribution with scale parameter `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.rayleigh.logpdf.factory( 4.0 );\n > var y = mylogpdf( 6.0 )\n ~-2.106\n > y = mylogpdf( 4.0 )\n ~-1.886\n\n"
+base.dists.rayleigh.mean,"\nbase.dists.rayleigh.mean( σ )\n Returns the expected value of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.rayleigh.mean( 11.0 )\n ~13.786\n > v = base.dists.rayleigh.mean( 4.5 )\n ~5.64\n\n"
+base.dists.rayleigh.median,"\nbase.dists.rayleigh.median( σ )\n Returns the median of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.rayleigh.median( 11.0 )\n ~12.952\n > v = base.dists.rayleigh.median( 4.5 )\n ~5.298\n\n"
+base.dists.rayleigh.mgf,"\nbase.dists.rayleigh.mgf( t, sigma )\n Evaluates the moment-generating function (MGF) for a Rayleigh distribution\n with scale parameter `sigma` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.rayleigh.mgf( 1.0, 3.0 )\n ~678.508\n > y = base.dists.rayleigh.mgf( 1.0, 2.0 )\n ~38.65\n > y = base.dists.rayleigh.mgf( -1.0, 4.0 )\n ~-0.947\n > y = base.dists.rayleigh.mgf( NaN, 1.0 )\n NaN\n > y = base.dists.rayleigh.mgf( 0.0, NaN )\n NaN\n > y = base.dists.rayleigh.mgf( 0.5, -1.0 )\n NaN\n\n\nbase.dists.rayleigh.mgf.factory( sigma )\n Returns a function for evaluating the moment-generating function (MGF) of a\n Rayleigh distribution with scale parameter `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.rayleigh.mgf.factory( 0.5 );\n > var y = myMGF( 1.0 )\n ~2.715\n > y = myMGF( 0.5 )\n ~1.888\n\n"
+base.dists.rayleigh.mode,"\nbase.dists.rayleigh.mode( σ )\n Returns the mode of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.rayleigh.mode( 11.0 )\n 11.0\n > v = base.dists.rayleigh.mode( 4.5 )\n 4.5\n\n"
+base.dists.rayleigh.pdf,"\nbase.dists.rayleigh.pdf( x, sigma )\n Evaluates the probability density function (PDF) for a Rayleigh\n distribution with scale parameter `sigma` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative value for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.rayleigh.pdf( 0.3, 1.0 )\n ~0.287\n > y = base.dists.rayleigh.pdf( 2.0, 0.8 )\n ~0.137\n > y = base.dists.rayleigh.pdf( -1.0, 0.5 )\n 0.0\n > y = base.dists.rayleigh.pdf( 0.0, NaN )\n NaN\n > y = base.dists.rayleigh.pdf( NaN, 2.0 )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.rayleigh.pdf( 2.0, -1.0 )\n NaN\n\n // Degenerate distribution when `sigma = 0.0`:\n > y = base.dists.rayleigh.pdf( -2.0, 0.0 )\n 0.0\n > y = base.dists.rayleigh.pdf( 0.0, 0.0 )\n Infinity\n > y = base.dists.rayleigh.pdf( 2.0, 0.0 )\n 0.0\n\n\nbase.dists.rayleigh.pdf.factory( sigma )\n Returns a function for evaluating the probability density function (PDF) of\n a Rayleigh distribution with scale parameter `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.rayleigh.pdf.factory( 4.0 );\n > var y = myPDF( 6.0 )\n ~0.122\n > y = myPDF( 4.0 )\n ~0.152\n\n"
+base.dists.rayleigh.quantile,"\nbase.dists.rayleigh.quantile( p, sigma )\n Evaluates the quantile function for a Rayleigh distribution with scale\n parameter `sigma` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a negative probability for `sigma`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n sigma: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.rayleigh.quantile( 0.8, 1.0 )\n ~1.794\n > y = base.dists.rayleigh.quantile( 0.5, 4.0 )\n ~4.71\n\n > y = base.dists.rayleigh.quantile( 1.1, 1.0 )\n NaN\n > y = base.dists.rayleigh.quantile( -0.2, 1.0 )\n NaN\n\n > y = base.dists.rayleigh.quantile( NaN, 1.0 )\n NaN\n > y = base.dists.rayleigh.quantile( 0.0, NaN )\n NaN\n\n // Negative scale parameter:\n > y = base.dists.rayleigh.quantile( 0.5, -1.0 )\n NaN\n\n\nbase.dists.rayleigh.quantile.factory( sigma )\n Returns a function for evaluating the quantile function of a Rayleigh\n distribution with scale parameter `sigma`.\n\n Parameters\n ----------\n sigma: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.rayleigh.quantile.factory( 0.4 );\n > var y = myQuantile( 0.4 )\n ~0.404\n > y = myQuantile( 1.0 )\n Infinity\n\n"
+base.dists.rayleigh.Rayleigh,"\nbase.dists.rayleigh.Rayleigh( [σ] )\n Returns a Rayleigh distribution object.\n\n Parameters\n ----------\n σ: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n rayleigh: Object\n Distribution instance.\n\n rayleigh.sigma: number\n Scale parameter. If set, the value must be greater than `0`.\n\n rayleigh.entropy: number\n Read-only property which returns the differential entropy.\n\n rayleigh.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n rayleigh.mean: number\n Read-only property which returns the expected value.\n\n rayleigh.median: number\n Read-only property which returns the median.\n\n rayleigh.mode: number\n Read-only property which returns the mode.\n\n rayleigh.skewness: number\n Read-only property which returns the skewness.\n\n rayleigh.stdev: number\n Read-only property which returns the standard deviation.\n\n rayleigh.variance: number\n Read-only property which returns the variance.\n\n rayleigh.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n rayleigh.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n rayleigh.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n rayleigh.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n rayleigh.pdf: Function\n Evaluates the probability density function (PDF).\n\n rayleigh.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var rayleigh = base.dists.rayleigh.Rayleigh( 6.0 );\n > rayleigh.sigma\n 6.0\n > rayleigh.entropy\n ~2.734\n > rayleigh.kurtosis\n ~0.245\n > rayleigh.mean\n ~7.52\n > rayleigh.median\n ~7.064\n > rayleigh.mode\n 6.0\n > rayleigh.skewness\n ~0.631\n > rayleigh.stdev\n ~3.931\n > rayleigh.variance\n ~15.451\n > rayleigh.cdf( 1.0 )\n ~0.014\n > rayleigh.logcdf( 1.0 )\n ~-4.284\n > rayleigh.logpdf( 1.5 )\n ~-3.209\n > rayleigh.mgf( -0.5 )\n ~-0.91\n > rayleigh.pdf( 1.5 )\n ~0.04\n > rayleigh.quantile( 0.5 )\n ~7.064\n\n"
+base.dists.rayleigh.skewness,"\nbase.dists.rayleigh.skewness( σ )\n Returns the skewness of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.rayleigh.skewness( 11.0 )\n ~0.631\n > v = base.dists.rayleigh.skewness( 4.5 )\n ~0.631\n\n"
+base.dists.rayleigh.stdev,"\nbase.dists.rayleigh.stdev( σ )\n Returns the standard deviation of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.rayleigh.stdev( 9.0 )\n ~5.896\n > v = base.dists.rayleigh.stdev( 4.5 )\n ~2.948\n\n"
+base.dists.rayleigh.variance,"\nbase.dists.rayleigh.variance( σ )\n Returns the variance of a Rayleigh distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `σ < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n σ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.rayleigh.variance( 9.0 )\n ~34.765\n > v = base.dists.rayleigh.variance( 4.5 )\n ~8.691\n\n"
+base.dists.t.cdf,"\nbase.dists.t.cdf( x, v )\n Evaluates the cumulative distribution function (CDF) for a Student's t\n distribution with degrees of freedom `v` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `v`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.t.cdf( 2.0, 0.1 )\n ~0.611\n > y = base.dists.t.cdf( 1.0, 2.0 )\n ~0.789\n > y = base.dists.t.cdf( -1.0, 4.0 )\n ~0.187\n > y = base.dists.t.cdf( NaN, 1.0 )\n NaN\n > y = base.dists.t.cdf( 0.0, NaN )\n NaN\n > y = base.dists.t.cdf( 2.0, -1.0 )\n NaN\n\n\nbase.dists.t.cdf.factory( v )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Student's t distribution with degrees of freedom `v`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.t.cdf.factory( 0.5 );\n > var y = mycdf( 3.0 )\n ~0.816\n > y = mycdf( 1.0 )\n ~0.699\n\n"
+base.dists.t.entropy,"\nbase.dists.t.entropy( v )\n Returns the differential entropy of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.t.entropy( 11.0 )\n ~1.512\n > v = base.dists.t.entropy( 4.5 )\n ~1.652\n\n"
+base.dists.t.kurtosis,"\nbase.dists.t.kurtosis( v )\n Returns the excess kurtosis of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v <= 2`, the function returns `NaN`.\n\n If provided `2 < v <= 4`, the function returns positive infinity.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.t.kurtosis( 11.0 )\n ~0.857\n > v = base.dists.t.kurtosis( 4.5 )\n 12.0\n\n"
+base.dists.t.mean,"\nbase.dists.t.mean( v )\n Returns the expected value of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v <= 1`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.t.mean( 11.0 )\n 0.0\n > v = base.dists.t.mean( 4.5 )\n 0.0\n\n"
+base.dists.t.median,"\nbase.dists.t.median( v )\n Returns the median of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.t.median( 11.0 )\n 0.0\n > v = base.dists.t.median( 4.5 )\n 0.0\n\n"
+base.dists.t.mode,"\nbase.dists.t.mode( v )\n Returns the mode of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v < 0`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.t.mode( 11.0 )\n 0.0\n > v = base.dists.t.mode( 4.5 )\n 0.0\n\n"
+base.dists.t.pdf,"\nbase.dists.t.pdf( x, v )\n Evaluates the probability density function (PDF) for a Student's t\n distribution with degrees of freedom `v` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `v`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.t.pdf( 0.3, 4.0 )\n ~0.355\n > y = base.dists.t.pdf( 2.0, 0.7 )\n ~0.058\n > y = base.dists.t.pdf( -1.0, 0.5 )\n ~0.118\n > y = base.dists.t.pdf( 0.0, NaN )\n NaN\n > y = base.dists.t.pdf( NaN, 2.0 )\n NaN\n > y = base.dists.t.pdf( 2.0, -1.0 )\n NaN\n\n\nbase.dists.t.pdf.factory( v )\n Returns a function for evaluating the probability density function (PDF)\n of a Student's t distribution with degrees of freedom `v`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.t.pdf.factory( 3.0 );\n > var y = myPDF( 1.0 )\n ~0.207\n\n"
+base.dists.t.quantile,"\nbase.dists.t.quantile( p, v )\n Evaluates the quantile function for a Student's t distribution with degrees\n of freedom `v` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `v`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.t.quantile( 0.8, 1.0 )\n ~1.376\n > y = base.dists.t.quantile( 0.1, 1.0 )\n ~-3.078\n > y = base.dists.t.quantile( 0.5, 0.1 )\n 0.0\n\n > y = base.dists.t.quantile( -0.2, 0.1 )\n NaN\n\n > y = base.dists.t.quantile( NaN, 1.0 )\n NaN\n > y = base.dists.t.quantile( 0.0, NaN )\n NaN\n\n > y = base.dists.t.quantile( 0.5, -1.0 )\n NaN\n\n\nbase.dists.t.quantile.factory( v )\n Returns a function for evaluating the quantile function of a Student's t\n distribution with degrees of freedom `v`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.t.quantile.factory( 4.0 );\n > var y = myQuantile( 0.2 )\n ~-0.941\n > y = myQuantile( 0.9 )\n ~1.533\n\n"
+base.dists.t.skewness,"\nbase.dists.t.skewness( v )\n Returns the skewness of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `v <= 3`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.t.skewness( 11.0 )\n 0.0\n > v = base.dists.t.skewness( 4.5 )\n 0.0\n\n"
+base.dists.t.stdev,"\nbase.dists.t.stdev( v )\n Returns the standard deviation of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `1 < v <= 2`, the function returns positive infinity.\n\n If provided `v <= 1`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.t.stdev( 9.0 )\n ~1.134\n > v = base.dists.t.stdev( 4.5 )\n ~1.342\n\n"
+base.dists.t.T,"\nbase.dists.t.T( [v] )\n Returns a Student's t distribution object.\n\n Parameters\n ----------\n v: number (optional)\n Degrees of freedom. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n t: Object\n Distribution instance.\n\n t.v: number\n Degrees of freedom. If set, the value must be greater than `0`.\n\n t.entropy: number\n Read-only property which returns the differential entropy.\n\n t.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n t.mean: number\n Read-only property which returns the expected value.\n\n t.median: number\n Read-only property which returns the median.\n\n t.mode: number\n Read-only property which returns the mode.\n\n t.skewness: number\n Read-only property which returns the skewness.\n\n t.stdev: number\n Read-only property which returns the standard deviation.\n\n t.variance: number\n Read-only property which returns the variance.\n\n t.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n t.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n t.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n t.pdf: Function\n Evaluates the probability density function (PDF).\n\n t.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var t = base.dists.t.T( 6.0 );\n > t.v\n 6.0\n > t.entropy\n ~1.592\n > t.kurtosis\n 3.0\n > t.mean\n 0.0\n > t.median\n 0.0\n > t.mode\n 0.0\n > t.skewness\n 0.0\n > t.stdev\n ~1.225\n > t.variance\n 1.5\n > t.cdf( 1.0 )\n ~0.822\n > t.logcdf( 1.0 )\n ~-0.196\n > t.logpdf( 1.5 )\n ~-2.075\n > t.pdf( 1.5 )\n ~0.126\n > t.quantile( 0.8 )\n ~0.906\n\n"
+base.dists.t.variance,"\nbase.dists.t.variance( v )\n Returns the variance of a Student's t distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `1 < v <= 2`, the function returns positive infinity.\n\n If provided `v <= 1`, the function returns `NaN`.\n\n Parameters\n ----------\n v: number\n Degrees of freedom.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.t.variance( 9.0 )\n ~1.286\n > v = base.dists.t.variance( 4.5 )\n ~1.8\n\n"
+base.dists.triangular.cdf,"\nbase.dists.triangular.cdf( x, a, b, c )\n Evaluates the cumulative distribution function (CDF) for a triangular\n distribution with minimum support `a`, maximum support `b`, and mode `c` at\n a value `x`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.0 )\n 0.875\n > y = base.dists.triangular.cdf( 0.5, -1.0, 1.0, 0.5 )\n 0.75\n > y = base.dists.triangular.cdf( -10.0, -20.0, 0.0, -2.0 )\n ~0.278\n > y = base.dists.triangular.cdf( -2.0, -1.0, 1.0, 0.0 )\n 0.0\n > y = base.dists.triangular.cdf( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.cdf( 0.0, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.cdf( 0.0, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.cdf( 2.0, 1.0, 0.0, NaN )\n NaN\n > y = base.dists.triangular.cdf( 2.0, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.cdf.factory( a, b, c )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a triangular distribution with minimum support `a`, maximum support `b`,\n and mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.triangular.cdf.factory( 0.0, 10.0, 2.0 );\n > var y = mycdf( 0.5 )\n 0.0125\n > y = mycdf( 8.0 )\n 0.95\n\n\n"
+base.dists.triangular.entropy,"\nbase.dists.triangular.entropy( a, b, c )\n Returns the differential entropy of a triangular distribution (in nats).\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.triangular.entropy( 0.0, 1.0, 0.8 )\n ~-0.193\n > v = base.dists.triangular.entropy( 4.0, 12.0, 5.0 )\n ~1.886\n > v = base.dists.triangular.entropy( 2.0, 8.0, 5.0 )\n ~1.599\n\n"
+base.dists.triangular.kurtosis,"\nbase.dists.triangular.kurtosis( a, b, c )\n Returns the excess kurtosis of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.triangular.kurtosis( 0.0, 1.0, 0.8 )\n -0.6\n > v = base.dists.triangular.kurtosis( 4.0, 12.0, 5.0 )\n -0.6\n > v = base.dists.triangular.kurtosis( 2.0, 8.0, 5.0 )\n -0.6\n\n"
+base.dists.triangular.logcdf,"\nbase.dists.triangular.logcdf( x, a, b, c )\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF) for a triangular distribution with minimum support `a`, maximum\n support `b`, and mode `c` at a value `x`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.0 )\n ~-0.134\n > y = base.dists.triangular.logcdf( 0.5, -1.0, 1.0, 0.5 )\n ~-0.288\n > y = base.dists.triangular.logcdf( -10.0, -20.0, 0.0, -2.0 )\n ~-1.281\n > y = base.dists.triangular.logcdf( -2.0, -1.0, 1.0, 0.0 )\n -Infinity\n > y = base.dists.triangular.logcdf( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.logcdf( 0.0, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.logcdf( 0.0, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, NaN )\n NaN\n > y = base.dists.triangular.logcdf( 2.0, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.logcdf.factory( a, b, c )\n Returns a function for evaluating the natural logarithm of the cumulative\n distribution function (CDF) of a triangular distribution with minimum\n support `a`, maximum support `b`, and mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n cdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.triangular.logcdf.factory( 0.0, 10.0, 2.0 );\n > var y = mylogcdf( 0.5 )\n ~-4.382\n > y = mylogcdf( 8.0 )\n ~-0.051\n\n\n"
+base.dists.triangular.logpdf,"\nbase.dists.triangular.logpdf( x, a, b, c )\n Evaluates the natural logarithm of the probability density function (PDF)\n for a triangular distribution with minimum support `a`, maximum support `b`,\n and mode `c` at a value `x`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.0 )\n ~-0.693\n > y = base.dists.triangular.logpdf( 0.5, -1.0, 1.0, 0.5 )\n 0.0\n > y = base.dists.triangular.logpdf( -10.0, -20.0, 0.0, -2.0 )\n ~-2.89\n > y = base.dists.triangular.logpdf( -2.0, -1.0, 1.0, 0.0 )\n -Infinity\n > y = base.dists.triangular.logpdf( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.logpdf( 0.0, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.logpdf( 0.0, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, NaN )\n NaN\n > y = base.dists.triangular.logpdf( 2.0, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.logpdf.factory( a, b, c )\n Returns a function for evaluating the natural logarithm of the probability\n density function (PDF) of a triangular distribution with minimum support\n `a`, maximum support `b`, and mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogpdf = base.dists.triangular.logpdf.factory( 0.0, 10.0, 5.0 );\n > var y = mylogpdf( 2.0 )\n ~-2.526\n > y = mylogpdf( 12.0 )\n -Infinity\n\n\n"
+base.dists.triangular.mean,"\nbase.dists.triangular.mean( a, b, c )\n Returns the expected value of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.triangular.mean( 0.0, 1.0, 0.8 )\n ~0.6\n > v = base.dists.triangular.mean( 4.0, 12.0, 5.0 )\n 7.0\n > v = base.dists.triangular.mean( 2.0, 8.0, 5.0 )\n 5.0\n\n"
+base.dists.triangular.median,"\nbase.dists.triangular.median( a, b, c )\n Returns the median of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.triangular.median( 0.0, 1.0, 0.8 )\n ~0.632\n > v = base.dists.triangular.median( 4.0, 12.0, 5.0 )\n ~6.708\n > v = base.dists.triangular.median( 2.0, 8.0, 5.0 )\n 5.0\n\n"
+base.dists.triangular.mgf,"\nbase.dists.triangular.mgf( t, a, b, c )\n Evaluates the moment-generating function (MGF) for a triangular distribution\n with minimum support `a`, maximum support `b`, and mode `c` at a value `t`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.0 )\n ~1.021\n > y = base.dists.triangular.mgf( 0.5, -1.0, 1.0, 0.5 )\n ~1.111\n > y = base.dists.triangular.mgf( -0.3, -20.0, 0.0, -2.0 )\n ~24.334\n > y = base.dists.triangular.mgf( -2.0, -1.0, 1.0, 0.0 )\n ~1.381\n > y = base.dists.triangular.mgf( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.mgf( 0.0, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.mgf( 0.0, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.mgf( 0.5, 1.0, 0.0, NaN )\n NaN\n > y = base.dists.triangular.mgf( 0.5, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.mgf.factory( a, b, c )\n Returns a function for evaluating the moment-generating function (MGF) of a\n triangular distribution with minimum support `a`, maximum support `b`, and\n mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.triangular.mgf.factory( 0.0, 2.0, 1.0 );\n > var y = mymgf( -1.0 )\n ~0.3996\n > y = mymgf( 2.0 )\n ~10.205\n\n\n"
+base.dists.triangular.mode,"\nbase.dists.triangular.mode( a, b, c )\n Returns the mode of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.triangular.mode( 0.0, 1.0, 0.8 )\n 0.8\n > v = base.dists.triangular.mode( 4.0, 12.0, 5.0 )\n 5.0\n > v = base.dists.triangular.mode( 2.0, 8.0, 5.0 )\n 5.0\n\n"
+base.dists.triangular.pdf,"\nbase.dists.triangular.pdf( x, a, b, c )\n Evaluates the probability density function (PDF) for a triangular\n distribution with minimum support `a`, maximum support `b`, and mode `c` at\n a value `x`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.0 )\n 0.5\n > y = base.dists.triangular.pdf( 0.5, -1.0, 1.0, 0.5 )\n 1.0\n > y = base.dists.triangular.pdf( -10.0, -20.0, 0.0, -2.0 )\n ~0.056\n > y = base.dists.triangular.pdf( -2.0, -1.0, 1.0, 0.0 )\n 0.0\n > y = base.dists.triangular.pdf( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.pdf( 0.0, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.pdf( 0.0, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.pdf( 2.0, 1.0, 0.0, NaN )\n NaN\n > y = base.dists.triangular.pdf( 2.0, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.pdf.factory( a, b, c )\n Returns a function for evaluating the probability density function (PDF) of\n a triangular distribution with minimum support `a`, maximum support `b`, and\n mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var mypdf = base.dists.triangular.pdf.factory( 0.0, 10.0, 5.0 );\n > var y = mypdf( 2.0 )\n 0.08\n > y = mypdf( 12.0 )\n 0.0\n\n\n"
+base.dists.triangular.quantile,"\nbase.dists.triangular.quantile( p, a, b, c )\n Evaluates the quantile function for a triangular distribution with minimum\n support `a`, maximum support `b`, and mode `c` at a value `x`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n If either `a`, `b`, or `c` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.triangular.quantile( 0.9, -1.0, 1.0, 0.0 )\n ~0.553\n > y = base.dists.triangular.quantile( 0.1, -1.0, 1.0, 0.5 )\n ~-0.452\n > y = base.dists.triangular.quantile( 0.1, -20.0, 0.0, -2.0 )\n -14.0\n > y = base.dists.triangular.quantile( 0.8, 0.0, 20.0, 0.0 )\n ~11.056\n\n > y = base.dists.triangular.quantile( 1.1, -1.0, 1.0, 0.0 )\n NaN\n > y = base.dists.triangular.quantile( -0.1, -1.0, 1.0, 0.0 )\n NaN\n\n > y = base.dists.triangular.quantile( NaN, 0.0, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.quantile( 0.3, NaN, 1.0, 0.5 )\n NaN\n > y = base.dists.triangular.quantile( 0.3, 0.0, NaN, 0.5 )\n NaN\n > y = base.dists.triangular.quantile( 0.3, 1.0, 0.0, NaN )\n NaN\n\n > y = base.dists.triangular.quantile( 0.3, 1.0, 0.0, 1.5 )\n NaN\n\n\nbase.dists.triangular.quantile.factory( a, b, c )\n Returns a function for evaluating the quantile function of a triangular\n distribution with minimum support `a`, maximum support `b`, and mode `c`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myquantile = base.dists.triangular.quantile.factory( 2.0, 4.0, 2.5 );\n > var y = myquantile( 0.4 )\n ~2.658\n > y = myquantile( 0.8 )\n ~3.225\n\n\n"
+base.dists.triangular.skewness,"\nbase.dists.triangular.skewness( a, b, c )\n Returns the skewness of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.triangular.skewness( 0.0, 1.0, 0.8 )\n ~-0.476\n > v = base.dists.triangular.skewness( 4.0, 12.0, 5.0 )\n ~0.532\n > v = base.dists.triangular.skewness( 2.0, 8.0, 5.0 )\n 0.0\n\n"
+base.dists.triangular.stdev,"\nbase.dists.triangular.stdev( a, b, c )\n Returns the standard deviation of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.triangular.stdev( 0.0, 1.0, 0.8 )\n ~0.216\n > v = base.dists.triangular.stdev( 4.0, 12.0, 5.0 )\n ~1.78\n > v = base.dists.triangular.stdev( 2.0, 8.0, 5.0 )\n ~1.225\n\n"
+base.dists.triangular.Triangular,"\nbase.dists.triangular.Triangular( [a, b, c] )\n Returns a triangular distribution object.\n\n Parameters\n ----------\n a: number (optional)\n Minimum support. Must be smaller than `b` and `c`. Default: `0.0`.\n\n b: number (optional)\n Maximum support. Must be greater than `a` and `c`. Default: `1.0`.\n\n c: number (optional)\n Mode. Must be greater than `a` and smaller than `b`. Default: `0.5`.\n\n Returns\n -------\n triangular: Object\n Distribution instance.\n\n triangular.a: number\n Minimum support. If set, the value must be smaller or equal to `b` and\n `c`.\n\n triangular.b: number\n Maximum support. If set, the value must be greater than or equal to `a`\n and `c`.\n\n triangular.c: number\n Mode. If set, the value must be greater than or equal to `a` and smaller\n than or equal to `b`.\n\n triangular.entropy: number\n Read-only property which returns the differential entropy.\n\n triangular.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n triangular.mean: number\n Read-only property which returns the expected value.\n\n triangular.median: number\n Read-only property which returns the median.\n\n triangular.mode: number\n Read-only property which returns the mode.\n\n triangular.skewness: number\n Read-only property which returns the skewness.\n\n triangular.stdev: number\n Read-only property which returns the standard deviation.\n\n triangular.variance: number\n Read-only property which returns the variance.\n\n triangular.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n triangular.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n triangular.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n triangular.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n triangular.pdf: Function\n Evaluates the probability density function (PDF).\n\n triangular.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var triangular = base.dists.triangular.Triangular( 0.0, 1.0, 0.5 );\n > triangular.a\n 0.0\n > triangular.b\n 1.0\n > triangular.c\n 0.5\n > triangular.entropy\n ~-0.193\n > triangular.kurtosis\n -0.6\n > triangular.mean\n 0.5\n > triangular.median\n 0.5\n > triangular.mode\n 0.5\n > triangular.skewness\n 0.0\n > triangular.stdev\n ~0.204\n > triangular.variance\n ~0.042\n > triangular.cdf( 0.8 )\n 0.92\n > triangular.logcdf( 0.8 )\n ~-0.083\n > triangular.logpdf( 0.8 )\n ~-0.223\n > triangular.mgf( 0.8 )\n ~1.512\n > triangular.pdf( 0.8 )\n ~0.8\n > triangular.quantile( 0.8 )\n ~0.684\n\n"
+base.dists.triangular.variance,"\nbase.dists.triangular.variance( a, b, c )\n Returns the variance of a triangular distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If the condition `a <= c <= b` is not satisfied, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n c: number\n Mode.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.triangular.variance( 0.0, 1.0, 0.8 )\n ~0.047\n > v = base.dists.triangular.variance( 4.0, 12.0, 5.0 )\n ~3.167\n > v = base.dists.triangular.variance( 2.0, 8.0, 5.0 )\n ~1.5\n\n"
+base.dists.uniform.cdf,"\nbase.dists.uniform.cdf( x, a, b )\n Evaluates the cumulative distribution function (CDF) for a uniform\n distribution with minimum support `a` and maximum support `b` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.uniform.cdf( 9.0, 0.0, 10.0 )\n 0.9\n > y = base.dists.uniform.cdf( 0.5, 0.0, 2.0 )\n 0.25\n > y = base.dists.uniform.cdf( PINF, 2.0, 4.0 )\n 1.0\n > y = base.dists.uniform.cdf( NINF, 2.0, 4.0 )\n 0.0\n > y = base.dists.uniform.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.cdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.uniform.cdf( 2.0, 1.0, 0.0 )\n NaN\n\n\nbase.dists.uniform.cdf.factory( a, b )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a uniform distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mycdf = base.dists.uniform.cdf.factory( 0.0, 10.0 );\n > var y = mycdf( 0.5 )\n 0.05\n > y = mycdf( 8.0 )\n 0.8\n\n"
+base.dists.uniform.entropy,"\nbase.dists.uniform.entropy( a, b )\n Returns the differential entropy of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Differential entropy.\n\n Examples\n --------\n > var v = base.dists.uniform.entropy( 0.0, 1.0 )\n 0.0\n > v = base.dists.uniform.entropy( 4.0, 12.0 )\n ~2.079\n > v = base.dists.uniform.entropy( 2.0, 8.0 )\n ~1.792\n\n"
+base.dists.uniform.kurtosis,"\nbase.dists.uniform.kurtosis( a, b )\n Returns the excess kurtosis of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.uniform.kurtosis( 0.0, 1.0 )\n -1.2\n > v = base.dists.uniform.kurtosis( 4.0, 12.0 )\n -1.2\n > v = base.dists.uniform.kurtosis( 2.0, 8.0 )\n -1.2\n\n"
+base.dists.uniform.logcdf,"\nbase.dists.uniform.logcdf( x, a, b )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n uniform distribution with minimum support `a` and maximum support `b` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.uniform.logcdf( 9.0, 0.0, 10.0 )\n ~-0.105\n > y = base.dists.uniform.logcdf( 0.5, 0.0, 2.0 )\n ~-1.386\n > y = base.dists.uniform.logcdf( PINF, 2.0, 4.0 )\n 0.0\n > y = base.dists.uniform.logcdf( NINF, 2.0, 4.0 )\n -Infinity\n > y = base.dists.uniform.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.logcdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.uniform.logcdf( 2.0, 1.0, 0.0 )\n NaN\n\n\nbase.dists.uniform.logcdf.factory( a, b )\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a uniform distribution with minimum support\n `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n logcdf: Function\n Logarithm of Cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.uniform.logcdf.factory( 0.0, 10.0 );\n > var y = mylogcdf( 0.5 )\n ~-2.996\n > y = mylogcdf( 8.0 )\n ~-0.223\n\n"
+base.dists.uniform.logpdf,"\nbase.dists.uniform.logpdf( x, a, b )\n Evaluates the logarithm of the probability density function (PDF) for a\n uniform distribution with minimum support `a` and maximum support `b` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.uniform.logpdf( 2.0, 0.0, 4.0 )\n ~-1.386\n > y = base.dists.uniform.logpdf( 5.0, 0.0, 4.0 )\n -infinity\n > y = base.dists.uniform.logpdf( 0.25, 0.0, 1.0 )\n 0.0\n > y = base.dists.uniform.logpdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.logpdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.uniform.logpdf( 2.0, 3.0, 1.0 )\n NaN\n\n\nbase.dists.uniform.logpdf.factory( a, b )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a uniform distribution with minimum support `a` and\n maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylogPDF = base.dists.uniform.logpdf.factory( 6.0, 7.0 );\n > var y = mylogPDF( 7.0 )\n 0.0\n > y = mylogPDF( 5.0 )\n -infinity\n\n"
+base.dists.uniform.mean,"\nbase.dists.uniform.mean( a, b )\n Returns the expected value of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.uniform.mean( 0.0, 1.0 )\n 0.5\n > v = base.dists.uniform.mean( 4.0, 12.0 )\n 8.0\n > v = base.dists.uniform.mean( 2.0, 8.0 )\n 5.0\n\n"
+base.dists.uniform.median,"\nbase.dists.uniform.median( a, b )\n Returns the median of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.uniform.median( 0.0, 1.0 )\n 0.5\n > v = base.dists.uniform.median( 4.0, 12.0 )\n 8.0\n > v = base.dists.uniform.median( 2.0, 8.0 )\n 5.0\n\n"
+base.dists.uniform.mgf,"\nbase.dists.uniform.mgf( t, a, b )\n Evaluates the moment-generating function (MGF) for a uniform\n distribution with minimum support `a` and maximum support `b` at a value\n `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n t: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.uniform.mgf( 2.0, 0.0, 4.0 )\n ~372.495\n > y = base.dists.uniform.mgf( -0.2, 0.0, 4.0 )\n ~0.688\n > y = base.dists.uniform.mgf( 2.0, 0.0, 1.0 )\n ~3.195\n > y = base.dists.uniform.mgf( 0.5, 3.0, 2.0 )\n NaN\n > y = base.dists.uniform.mgf( 0.5, 3.0, 3.0 )\n NaN\n > y = base.dists.uniform.mgf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.mgf( 0.0, 0.0, NaN )\n NaN\n\n\nbase.dists.uniform.mgf.factory( a, b )\n Returns a function for evaluating the moment-generating function (MGF)\n of a uniform distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var mymgf = base.dists.uniform.mgf.factory( 6.0, 7.0 );\n > var y = mymgf( 0.1 )\n ~1.916\n > y = mymgf( 1.1 )\n ~1339.321\n\n"
+base.dists.uniform.pdf,"\nbase.dists.uniform.pdf( x, a, b )\n Evaluates the probability density function (PDF) for a uniform distribution\n with minimum support `a` and maximum support `b` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.uniform.pdf( 2.0, 0.0, 4.0 )\n 0.25\n > y = base.dists.uniform.pdf( 5.0, 0.0, 4.0 )\n 0.0\n > y = base.dists.uniform.pdf( 0.25, 0.0, 1.0 )\n 1.0\n > y = base.dists.uniform.pdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.pdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.uniform.pdf( 2.0, 3.0, 1.0 )\n NaN\n\n\nbase.dists.uniform.pdf.factory( a, b )\n Returns a function for evaluating the probability density function (PDF) of\n a uniform distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.uniform.pdf.factory( 6.0, 7.0 );\n > var y = myPDF( 7.0 )\n 1.0\n > y = myPDF( 5.0 )\n 0.0\n\n"
+base.dists.uniform.quantile,"\nbase.dists.uniform.quantile( p, a, b )\n Evaluates the quantile function for a uniform distribution with minimum\n support `a` and maximum support `b` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.uniform.quantile( 0.8, 0.0, 1.0 )\n 0.8\n > y = base.dists.uniform.quantile( 0.5, 0.0, 10.0 )\n 5.0\n\n > y = base.dists.uniform.quantile( 1.1, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.quantile( -0.2, 0.0, 1.0 )\n NaN\n\n > y = base.dists.uniform.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.uniform.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.uniform.quantile( 0.0, 0.0, NaN )\n NaN\n\n > y = base.dists.uniform.quantile( 0.5, 2.0, 1.0 )\n NaN\n\n\nbase.dists.uniform.quantile.factory( a, b )\n Returns a function for evaluating the quantile function of a uniform\n distribution with minimum support `a` and maximum support `b`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.uniform.quantile.factory( 0.0, 4.0 );\n > var y = myQuantile( 0.8 )\n 3.2\n\n"
+base.dists.uniform.skewness,"\nbase.dists.uniform.skewness( a, b )\n Returns the skewness of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.uniform.skewness( 0.0, 1.0 )\n 0.0\n > v = base.dists.uniform.skewness( 4.0, 12.0 )\n 0.0\n > v = base.dists.uniform.skewness( 2.0, 8.0 )\n 0.0\n\n"
+base.dists.uniform.stdev,"\nbase.dists.uniform.stdev( a, b )\n Returns the standard deviation of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.uniform.stdev( 0.0, 1.0 )\n ~0.289\n > v = base.dists.uniform.stdev( 4.0, 12.0 )\n ~2.309\n > v = base.dists.uniform.stdev( 2.0, 8.0 )\n ~1.732\n\n"
+base.dists.uniform.Uniform,"\nbase.dists.uniform.Uniform( [a, b] )\n Returns a uniform distribution object.\n\n Parameters\n ----------\n a: number (optional)\n Minimum support. Must be smaller than `b`. Default: `0.0`.\n\n b: number (optional)\n Maximum support. Must be greater than `a`. Default: `1.0`.\n\n Returns\n -------\n uniform: Object\n Distribution instance.\n\n uniform.a: number\n Minimum support. If set, the value must be smaller than `b`.\n\n uniform.b: number\n Maximum support. If set, the value must be greater than `a`.\n\n uniform.entropy: number\n Read-only property which returns the differential entropy.\n\n uniform.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n uniform.mean: number\n Read-only property which returns the expected value.\n\n uniform.median: number\n Read-only property which returns the median.\n\n uniform.skewness: number\n Read-only property which returns the skewness.\n\n uniform.stdev: number\n Read-only property which returns the standard deviation.\n\n uniform.variance: number\n Read-only property which returns the variance.\n\n uniform.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n uniform.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n uniform.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n uniform.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n uniform.pdf: Function\n Evaluates the probability density function (PDF).\n\n uniform.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var uniform = base.dists.uniform.Uniform( 0.0, 1.0 );\n > uniform.a\n 0.0\n > uniform.b\n 1.0\n > uniform.entropy\n 0.0\n > uniform.kurtosis\n -1.2\n > uniform.mean\n 0.5\n > uniform.median\n 0.5\n > uniform.skewness\n 0.0\n > uniform.stdev\n ~0.289\n > uniform.variance\n ~0.083\n > uniform.cdf( 0.8 )\n 0.8\n > uniform.logcdf( 0.5 )\n ~-0.693\n > uniform.logpdf( 1.0 )\n ~-0.0\n > uniform.mgf( 0.8 )\n ~1.532\n > uniform.pdf( 0.8 )\n 1.0\n > uniform.quantile( 0.8 )\n 0.8\n\n"
+base.dists.uniform.variance,"\nbase.dists.uniform.variance( a, b )\n Returns the variance of a uniform distribution.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided `a >= b`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.uniform.variance( 0.0, 1.0 )\n ~0.083\n > v = base.dists.uniform.variance( 4.0, 12.0 )\n ~5.333\n > v = base.dists.uniform.variance( 2.0, 8.0 )\n 3.0\n\n"
+base.dists.weibull.cdf,"\nbase.dists.weibull.cdf( x, k, λ )\n Evaluates the cumulative distribution function (CDF) for a Weibull\n distribution with shape parameter `k` and scale parameter `λ` at a value\n `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated CDF.\n\n Examples\n --------\n > var y = base.dists.weibull.cdf( 2.0, 1.0, 1.0 )\n ~0.865\n > y = base.dists.weibull.cdf( -1.0, 2.0, 2.0 )\n 0.0\n > y = base.dists.weibull.cdf( PINF, 4.0, 2.0 )\n 1.0\n > y = base.dists.weibull.cdf( NINF, 4.0, 2.0 )\n 0.0\n > y = base.dists.weibull.cdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.weibull.cdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.cdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.weibull.cdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.weibull.cdf.factory( k, λ )\n Returns a function for evaluating the cumulative distribution function (CDF)\n of a Weibull distribution with shape parameter `k` and scale parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n cdf: Function\n Cumulative distribution function (CDF).\n\n Examples\n --------\n > var myCDF = base.dists.weibull.cdf.factory( 2.0, 10.0 );\n > var y = myCDF( 12.0 )\n ~0.763\n\n"
+base.dists.weibull.entropy,"\nbase.dists.weibull.entropy( k, λ )\n Returns the differential entropy of a Weibull distribution (in nats).\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Entropy.\n\n Examples\n --------\n > var v = base.dists.weibull.entropy( 1.0, 1.0 )\n 1.0\n > v = base.dists.weibull.entropy( 4.0, 12.0 )\n ~2.532\n > v = base.dists.weibull.entropy( 8.0, 2.0 )\n ~0.119\n\n"
+base.dists.weibull.kurtosis,"\nbase.dists.weibull.kurtosis( k, λ )\n Returns the excess kurtosis of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Excess kurtosis.\n\n Examples\n --------\n > var v = base.dists.weibull.kurtosis( 1.0, 1.0 )\n 6.0\n > v = base.dists.weibull.kurtosis( 4.0, 12.0 )\n ~-0.252\n > v = base.dists.weibull.kurtosis( 8.0, 2.0 )\n ~0.328\n\n"
+base.dists.weibull.logcdf,"\nbase.dists.weibull.logcdf( x, k, λ )\n Evaluates the logarithm of the cumulative distribution function (CDF) for a\n Weibull distribution with shape parameter `k` and scale parameter `λ` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a nonpositive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logCDF.\n\n Examples\n --------\n > var y = base.dists.weibull.logcdf( 2.0, 1.0, 1.0 )\n ~-0.145\n > y = base.dists.weibull.logcdf( -1.0, 2.0, 2.0 )\n -Infinity\n > y = base.dists.weibull.logcdf( PINF, 4.0, 2.0 )\n 0.0\n > y = base.dists.weibull.logcdf( NINF, 4.0, 2.0 )\n -Infinity\n > y = base.dists.weibull.logcdf( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.weibull.logcdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.logcdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.weibull.logcdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.weibull.logcdf.factory( k, λ)\n Returns a function for evaluating the logarithm of the cumulative\n distribution function (CDF) of a Weibull distribution with scale parameter\n `λ` and shape parameter `k`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n logcdf: Function\n Logarithm of cumulative distribution function (CDF).\n\n Examples\n --------\n > var mylogcdf = base.dists.weibull.logcdf.factory( 2.0, 10.0 );\n > var y = mylogcdf( 12.0 )\n ~-0.27\n\n"
+base.dists.weibull.logpdf,"\nbase.dists.weibull.logpdf( x, k, λ )\n Evaluates the logarithm of the probability density function (PDF) for a\n Weibull distribution with shape parameter `k` and scale parameter `λ` at a\n value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a nonpositive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated logPDF.\n\n Examples\n --------\n > var y = base.dists.weibull.logpdf( 2.0, 1.0, 0.5 )\n ~-3.307\n > y = base.dists.weibull.logpdf( 0.1, 1.0, 1.0 )\n ~-0.1\n > y = base.dists.weibull.logpdf( -1.0, 4.0, 2.0 )\n -Infinity\n > y = base.dists.weibull.logpdf( NaN, 0.6, 1.0 )\n NaN\n > y = base.dists.weibull.logpdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.logpdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.weibull.logpdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.weibull.logpdf.factory( k, λ )\n Returns a function for evaluating the logarithm of the probability density\n function (PDF) of a Weibull distribution with shape parameter `k` and scale\n parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n logpdf: Function\n Logarithm of probability density function (PDF).\n\n Examples\n --------\n > var mylofpdf = base.dists.weibull.logpdf.factory( 7.0, 6.0 );\n > y = mylofpdf( 7.0 )\n ~-1.863\n\n"
+base.dists.weibull.mean,"\nbase.dists.weibull.mean( k, λ )\n Returns the expected value of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Expected value.\n\n Examples\n --------\n > var v = base.dists.weibull.mean( 1.0, 1.0 )\n 1.0\n > v = base.dists.weibull.mean( 4.0, 12.0 )\n ~10.877\n > v = base.dists.weibull.mean( 8.0, 2.0 )\n ~1.883\n\n"
+base.dists.weibull.median,"\nbase.dists.weibull.median( k, λ )\n Returns the median of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Median.\n\n Examples\n --------\n > var v = base.dists.weibull.median( 1.0, 1.0 )\n ~0.693\n > v = base.dists.weibull.median( 4.0, 12.0 )\n ~10.949\n > v = base.dists.weibull.median( 8.0, 2.0 )\n ~1.91\n\n"
+base.dists.weibull.mgf,"\nbase.dists.weibull.mgf( x, k, λ )\n Evaluates the moment-generating function (MGF) for a Weibull distribution\n with shape parameter `k` and scale parameter `λ` at a value `t`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a non-positive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated MGF.\n\n Examples\n --------\n > var y = base.dists.weibull.mgf( 1.0, 1.0, 0.5 )\n ~2.0\n > y = base.dists.weibull.mgf( -1.0, 4.0, 4.0 )\n ~0.019\n\n > y = base.dists.weibull.mgf( NaN, 1.0, 1.0 )\n NaN\n > y = base.dists.weibull.mgf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.mgf( 0.0, 1.0, NaN )\n NaN\n\n > y = base.dists.weibull.mgf( 0.2, -1.0, 0.5 )\n NaN\n > y = base.dists.weibull.mgf( 0.2, 0.0, 0.5 )\n NaN\n\n > y = base.dists.weibull.mgf( 0.2, 0.5, -1.0 )\n NaN\n > y = base.dists.weibull.mgf( 0.2, 0.5, 0.0 )\n NaN\n\n\nbase.dists.weibull.mgf.factory( k, λ )\n Returns a function for evaluating the moment-generating function (MGF) of a\n Weibull distribution with shape parameter `k` and scale parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n mgf: Function\n Moment-generating function (MGF).\n\n Examples\n --------\n > var myMGF = base.dists.weibull.mgf.factory( 8.0, 10.0 );\n > var y = myMGF( 0.8 )\n ~3150.149\n > y = myMGF( 0.08 )\n ~2.137\n\n"
+base.dists.weibull.mode,"\nbase.dists.weibull.mode( k, λ )\n Returns the mode of a Weibull distribution.\n\n If `0 < k <= 1`, the function returns `0.0`.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Mode.\n\n Examples\n --------\n > var v = base.dists.weibull.mode( 1.0, 1.0 )\n 0.0\n > v = base.dists.weibull.mode( 4.0, 12.0 )\n ~11.167\n > v = base.dists.weibull.mode( 8.0, 2.0 )\n ~1.967\n\n"
+base.dists.weibull.pdf,"\nbase.dists.weibull.pdf( x, k, λ )\n Evaluates the probability density function (PDF) for a Weibull distribution\n with shape parameter `k` and scale parameter `λ` at a value `x`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a nonpositive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated PDF.\n\n Examples\n --------\n > var y = base.dists.weibull.pdf( 2.0, 1.0, 0.5 )\n ~0.037\n > y = base.dists.weibull.pdf( 0.1, 1.0, 1.0 )\n ~0.905\n > y = base.dists.weibull.pdf( -1.0, 4.0, 2.0 )\n 0.0\n > y = base.dists.weibull.pdf( NaN, 0.6, 1.0 )\n NaN\n > y = base.dists.weibull.pdf( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.pdf( 0.0, 0.0, NaN )\n NaN\n > y = base.dists.weibull.pdf( 2.0, 0.0, -1.0 )\n NaN\n\n\nbase.dists.weibull.pdf.factory( k, λ )\n Returns a function for evaluating the probability density function (PDF) of\n a Weibull distribution with shape parameter `k` and scale parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n pdf: Function\n Probability density function (PDF).\n\n Examples\n --------\n > var myPDF = base.dists.weibull.pdf.factory( 7.0, 6.0 );\n > var y = myPDF( 7.0 )\n ~0.155\n\n"
+base.dists.weibull.quantile,"\nbase.dists.weibull.quantile( p, k, λ )\n Evaluates the quantile function for a Weibull distribution with scale\n parameter `k` and shape parameter `λ` at a probability `p`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n If provided `NaN` as any argument, the function returns `NaN`.\n\n If provided a nonpositive value for `λ` or `k`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input probability.\n\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Evaluated quantile function.\n\n Examples\n --------\n > var y = base.dists.weibull.quantile( 0.8, 1.0, 1.0 )\n ~1.609\n > y = base.dists.weibull.quantile( 0.5, 2.0, 4.0 )\n ~3.33\n\n > y = base.dists.weibull.quantile( 1.1, 1.0, 1.0 )\n NaN\n > y = base.dists.weibull.quantile( -0.2, 1.0, 1.0 )\n NaN\n\n > y = base.dists.weibull.quantile( NaN, 0.0, 1.0 )\n NaN\n > y = base.dists.weibull.quantile( 0.0, NaN, 1.0 )\n NaN\n > y = base.dists.weibull.quantile( 0.0, 0.0, NaN )\n NaN\n\n > y = base.dists.weibull.quantile( 0.5, 1.0, -1.0 )\n NaN\n\n\nbase.dists.weibull.quantile.factory( k, λ )\n Returns a function for evaluating the quantile function of a Weibull\n distribution with scale parameter `k` and shape parameter `λ`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n quantile: Function\n Quantile function.\n\n Examples\n --------\n > var myQuantile = base.dists.weibull.quantile.factory( 2.0, 10.0 );\n > var y = myQuantile( 0.4 )\n ~7.147\n\n"
+base.dists.weibull.skewness,"\nbase.dists.weibull.skewness( k, λ )\n Returns the skewness of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Skewness.\n\n Examples\n --------\n > var v = base.dists.weibull.skewness( 1.0, 1.0 )\n 2.0\n > v = base.dists.weibull.skewness( 4.0, 12.0 )\n ~-0.087\n > v = base.dists.weibull.skewness( 8.0, 2.0 )\n ~-0.534\n\n"
+base.dists.weibull.stdev,"\nbase.dists.weibull.stdev( k, λ )\n Returns the standard deviation of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Standard deviation.\n\n Examples\n --------\n > var v = base.dists.weibull.stdev( 1.0, 1.0 )\n 1.0\n > v = base.dists.weibull.stdev( 4.0, 12.0 )\n ~3.051\n > v = base.dists.weibull.stdev( 8.0, 2.0 )\n ~0.279\n\n"
+base.dists.weibull.variance,"\nbase.dists.weibull.variance( k, λ )\n Returns the variance of a Weibull distribution.\n\n If `k <= 0` or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Shape parameter.\n\n λ: number\n Scale parameter.\n\n Returns\n -------\n out: number\n Variance.\n\n Examples\n --------\n > var v = base.dists.weibull.variance( 1.0, 1.0 )\n 1.0\n > v = base.dists.weibull.variance( 4.0, 12.0 )\n ~9.311\n > v = base.dists.weibull.variance( 8.0, 2.0 )\n ~0.078\n\n"
+base.dists.weibull.Weibull,"\nbase.dists.weibull.Weibull( [k, λ] )\n Returns a Weibull distribution object.\n\n Parameters\n ----------\n k: number (optional)\n Shape parameter. Must be greater than `0`. Default: `1.0`.\n\n λ: number (optional)\n Scale parameter. Must be greater than `0`. Default: `1.0`.\n\n Returns\n -------\n weibull: Object\n Distribution instance.\n\n weibull.k: number\n Shape parameter. If set, the value must be greater than `0`.\n\n weibull.lambda: number\n Scale parameter. If set, the value must be greater than `0`.\n\n weibull.entropy: number\n Read-only property which returns the differential entropy.\n\n weibull.kurtosis: number\n Read-only property which returns the excess kurtosis.\n\n weibull.mean: number\n Read-only property which returns the expected value.\n\n weibull.median: number\n Read-only property which returns the median.\n\n weibull.mode: number\n Read-only property which returns the mode.\n\n weibull.skewness: number\n Read-only property which returns the skewness.\n\n weibull.stdev: number\n Read-only property which returns the standard deviation.\n\n weibull.variance: number\n Read-only property which returns the variance.\n\n weibull.cdf: Function\n Evaluates the cumulative distribution function (CDF).\n\n weibull.logcdf: Function\n Evaluates the natural logarithm of the cumulative distribution function\n (CDF).\n\n weibull.logpdf: Function\n Evaluates the natural logarithm of the probability density function\n (PDF).\n\n weibull.mgf: Function\n Evaluates the moment-generating function (MGF).\n\n weibull.pdf: Function\n Evaluates the probability density function (PDF).\n\n weibull.quantile: Function\n Evaluates the quantile function at probability `p`.\n\n Examples\n --------\n > var weibull = base.dists.weibull.Weibull( 6.0, 5.0 );\n > weibull.k\n 6.0\n > weibull.lambda\n 5.0\n > weibull.entropy\n ~1.299\n > weibull.kurtosis\n ~0.035\n > weibull.mean\n ~4.639\n > weibull.median\n ~4.704\n > weibull.mode\n ~4.85\n > weibull.skewness\n ~-0.373\n > weibull.stdev\n ~0.899\n > weibull.variance\n ~0.808\n > weibull.cdf( 3.0 )\n ~0.046\n > weibull.logcdf( 3.0 )\n ~-3.088\n > weibull.logpdf( 1.0 )\n ~-7.865\n > weibull.mgf( -0.5 )\n ~0.075\n > weibull.pdf( 3.0 )\n ~0.089\n > weibull.quantile( 0.8 )\n ~5.413\n\n"
+base.ellipe,"\nbase.ellipe( m )\n Computes the complete elliptic integral of the second kind.\n\n Parameters\n ----------\n m: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.ellipe( 0.5 )\n ~1.351\n > y = base.ellipe( -1.0 )\n ~1.910\n > y = base.ellipe( 2.0 )\n NaN\n > y = base.ellipe( PINF )\n NaN\n > y = base.ellipe( NINF )\n NaN\n > y = base.ellipe( NaN )\n NaN\n\n See Also\n --------\n base.ellipk\n"
+base.ellipk,"\nbase.ellipk( m )\n Computes the complete elliptic integral of the first kind.\n\n Parameters\n ----------\n m: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.ellipk( 0.5 )\n ~1.854\n > y = base.ellipk( -1.0 )\n ~1.311\n > y = base.ellipk( 2.0 )\n NaN\n > y = base.ellipk( PINF )\n NaN\n > y = base.ellipk( NINF )\n NaN\n > y = base.ellipk( NaN )\n NaN\n\n See Also\n --------\n base.ellipe\n"
+base.epsdiff,"\nbase.epsdiff( x, y[, scale] )\n Computes the relative difference of two real numbers in units of double-\n precision floating-point epsilon.\n\n By default, the function scales the absolute difference by dividing the\n absolute difference by the maximum absolute value of `x` and `y`. To scale\n by a different function, specify a scale function name.\n\n The following `scale` functions are supported:\n\n - 'max-abs': maximum absolute value of `x` and `y` (default).\n - 'max': maximum value of `x` and `y`.\n - 'min-abs': minimum absolute value of `x` and `y`.\n - 'min': minimum value of `x` and `y`.\n - 'mean-abs': arithmetic mean of the absolute values of `x` and `y`.\n - 'mean': arithmetic mean of `x` and `y`.\n - 'x': `x` (*noncommutative*).\n - 'y': `y` (*noncommutative*).\n\n To use a custom scale function, provide a function which accepts two numeric\n arguments `x` and `y`.\n\n If computing the relative difference in units of epsilon will result in\n overflow, the function returns the maximum double-precision floating-point\n number.\n\n If the absolute difference of `x` and `y` is `0`, the relative difference is\n always `0`.\n\n If `|x| = |y| = infinity`, the function returns `NaN`.\n\n If `|x| = |-y| = infinity`, the relative difference is `+infinity`.\n\n If a `scale` function returns `0`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n First number.\n\n y: number\n Second number.\n\n scale: string|Function (optional)\n Scale function. Default: `'max-abs'`.\n\n Returns\n -------\n out: number\n Relative difference in units of double-precision floating-point epsilon.\n\n Examples\n --------\n > var d = base.epsdiff( 12.15, 12.149999999999999 )\n ~0.658\n > d = base.epsdiff( 2.4341309458983933, 2.4341309458633909, 'mean-abs' )\n ~64761.512\n\n // Custom scale function:\n > function scale( x, y ) { return ( x > y ) ? y : x; };\n > d = base.epsdiff( 1.0000000000000002, 1.0000000000000100, scale )\n ~44\n\n See Also\n --------\n base.absdiff, base.reldiff\n"
+base.erf,"\nbase.erf( x )\n Evaluates the error function.\n\n If provided `NaN`, the function returns `NaN`.\n\n As the error function is an odd function (i.e., `erf(-x) == -erf(x)`), if\n provided `-0`, the function returns `-0`.\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.erf( 2.0 )\n ~0.9953\n > y = base.erf( -1.0 )\n ~-0.8427\n > y = base.erf( -0.0 )\n -0.0\n > y = base.erf( NaN )\n NaN\n\n See Also\n --------\n base.erfc, base.erfinv, base.erfcinv\n"
+base.erfc,"\nbase.erfc( x )\n Evaluates the complementary error function.\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 value.\n\n Examples\n --------\n > var y = base.erfc( 2.0 )\n ~0.0047\n > y = base.erfc( -1.0 )\n ~1.8427\n > y = base.erfc( 0.0 )\n 1.0\n > y = base.erfc( PINF )\n 0.0\n > y = base.erfc( NINF )\n 2.0\n > y = base.erfc( NaN )\n NaN\n\n See Also\n --------\n base.erf, base.erfinv, base.erfcinv\n"
+base.erfcinv,"\nbase.erfcinv( x )\n Evaluates the inverse complementary error function.\n\n The domain of `x` is restricted to `[0,2]`. If `x` is outside this interval,\n the function returns `NaN`.\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 value.\n\n Examples\n --------\n > var y = base.erfcinv( 0.5 )\n ~0.4769\n > y = base.erfcinv( 0.8 )\n ~0.1791\n > y = base.erfcinv( 0.0 )\n Infinity\n > y = base.erfcinv( 2.0 )\n -Infinity\n > y = base.erfcinv( NaN )\n NaN\n\n See Also\n --------\n base.erf, base.erfc, base.erfinv\n"
+base.erfinv,"\nbase.erfinv( x )\n Evaluates the inverse error function.\n\n If `|x| > 1`, the function returns `NaN`.\n\n If provided `NaN`, the function returns `NaN`.\n\n As the inverse error function is an odd function (i.e., `erfinv(-x) ==\n -erfinv(x)`), if provided `-0`, the function returns `-0`.\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.erfinv( 0.5 )\n ~0.4769\n > y = base.erfinv( 0.8 )\n ~0.9062\n > y = base.erfinv( 0.0 )\n 0.0\n > y = base.erfinv( -0.0 )\n -0.0\n > y = base.erfinv( -1.0 )\n -Infinity\n > y = base.erfinv( 1.0 )\n Infinity\n > y = base.erfinv( NaN )\n NaN\n\n See Also\n --------\n base.erf, base.erfc, base.erfcinv\n"
+base.eta,"\nbase.eta( s )\n Evaluates the Dirichlet eta function as a function of a real variable `s`.\n\n Parameters\n ----------\n s: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.eta( 0.0 )\n 0.5\n > y = base.eta( -1.0 )\n 0.25\n > y = base.eta( 1.0 )\n ~0.6931\n > y = base.eta( 3.14 )\n ~0.9096\n > y = base.eta( NaN )\n NaN\n\n"
+base.evalpoly,"\nbase.evalpoly( c, x )\n Evaluates a polynomial.\n\n Parameters\n ----------\n c: Array\n Polynomial coefficients sorted in ascending degree.\n\n x: number\n Value at which to evaluate the polynomial.\n\n Returns\n -------\n out: number\n Evaluated polynomial.\n\n Examples\n --------\n > var arr = [ 3.0, 2.0, 1.0 ];\n\n // 3*10^0 + 2*10^1 + 1*10^2\n > var v = base.evalpoly( arr, 10.0 )\n 123.0\n\n\nbase.evalpoly.factory( c )\n Returns a function for evaluating a polynomial.\n\n Parameters\n ----------\n c: Array\n Polynomial coefficients sorted in ascending degree.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a polynomial.\n\n Examples\n --------\n > var polyval = base.evalpoly.factory( [ 3.0, 2.0, 1.0 ] );\n\n // 3*10^0 + 2*10^1 + 1*10^2\n > var v = polyval( 10.0 )\n 123.0\n\n // 3*5^0 + 2*5^1 + 1*5^2\n > v = polyval( 5.0 )\n 38.0\n\n See Also\n --------\n base.evalrational\n"
+base.evalrational,"\nbase.evalrational( P, Q, x )\n Evaluates a rational function.\n\n A rational function `f(x)` is defined as\n\n P(x)\n f(x) = ----\n Q(x)\n\n where both `P(x)` and `Q(x)` are polynomials in `x`.\n\n The coefficients for both `P` and `Q` should be sorted in ascending degree.\n\n For polynomials of different degree, the coefficient array for the lower\n degree polynomial should be padded with zeros.\n\n Parameters\n ----------\n P: Array\n Numerator polynomial coefficients sorted in ascending degree.\n\n Q: Array\n Denominator polynomial coefficients sorted in ascending degree.\n\n x: number\n Value at which to evaluate the rational function.\n\n Returns\n -------\n out: number\n Evaluated rational function.\n\n Examples\n --------\n // 2x^3 + 4x^2 - 5x^1 - 6x^0\n > var P = [ -6.0, -5.0, 4.0, 2.0 ];\n\n // 0.5x^1 + 3x^0\n > var Q = [ 3.0, 0.5, 0.0, 0.0 ]; // zero-padded\n\n // Evaluate the rational function:\n > var v = base.evalrational( P, Q, 6.0 )\n 90.0\n\n\nbase.evalrational.factory( P, Q )\n Returns a function for evaluating a rational function.\n\n Parameters\n ----------\n P: Array\n Numerator polynomial coefficients sorted in ascending degree.\n\n Q: Array\n Denominator polynomial coefficients sorted in ascending degree.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a rational function.\n\n Examples\n --------\n > var P = [ 20.0, 8.0, 3.0 ];\n > var Q = [ 10.0, 9.0, 1.0 ];\n > var rational = base.evalrational.factory( P, Q );\n\n // (20*10^0 + 8*10^1 + 3*10^2) / (10*10^0 + 9*10^1 + 1*10^2):\n > var v = rational( 10.0 )\n 2.0\n\n // (20*2^0 + 8*2^1 + 3*2^2) / (10*2^0 + 9*2^1 + 1*2^2):\n > v = rational( 2.0 )\n 1.5\n\n See Also\n --------\n base.evalpoly\n"
+base.exp,"\nbase.exp( x )\n Evaluates the natural exponential function.\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.exp( 4.0 )\n ~54.5982\n > y = base.exp( -9.0 )\n ~1.234e-4\n > y = base.exp( 0.0 )\n 1.0\n > y = base.exp( NaN )\n NaN\n\n See Also\n --------\n base.exp10, base.exp2, base.expm1, base.ln\n"
+base.exp2,"\nbase.exp2( x )\n Evaluates the base 2 exponential function.\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.exp2( 3.0 )\n 8.0\n > y = base.exp2( -9.0 )\n ~0.002\n > y = base.exp2( 0.0 )\n 1.0\n > y = base.exp2( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.exp10\n"
+base.exp10,"\nbase.exp10( x )\n Evaluates the base 10 exponential function.\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.exp10( 3.0 )\n 1000\n > y = base.exp10( -9.0 )\n 1.0e-9\n > y = base.exp10( 0.0 )\n 1.0\n > y = base.exp10( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.exp2\n"
+base.expit,"\nbase.expit( x )\n Evaluates the standard logistic function.\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.expit( 0.0 )\n 0.5\n > y = base.expit( 1.0 )\n ~0.731\n > y = base.expit( -1.0 )\n ~0.269\n > y = base.expit( Infinity )\n 1.0\n > y = base.expit( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.logit"
+base.expm1,"\nbase.expm1( x )\n Computes `exp(x)-1`, where `exp(x)` is the natural exponential function.\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.expm1( 0.2 )\n ~0.221\n > y = base.expm1( -9.0 )\n ~-1.0\n > y = base.expm1( 0.0 )\n 0.0\n > y = base.expm1( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.expm1rel\n"
+base.expm1rel,"\nbase.expm1rel( x )\n Relative error exponential.\n\n When `x` is near zero,\n\n e^x - 1\n\n can suffer catastrophic cancellation (i.e., significant loss of precision).\n This function avoids the loss of precision when `x` is near 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.expm1rel( 0.0 )\n 1.0\n > y = base.expm1rel( 1.0 )\n ~1.718\n > y = base.expm1rel( -1.0 )\n ~0.632\n > y = base.expm1rel( NaN )\n NaN\n \n See Also\n --------\n base.exp, base.expm1\n"
+base.exponent,"\nbase.exponent( x )\n Returns an integer corresponding to the unbiased exponent of a double-\n precision floating-point number.\n\n Parameters\n ----------\n x: number\n Double-precision floating-point number.\n\n Returns\n -------\n out: integer\n Unbiased exponent.\n\n Examples\n --------\n > var exponent = base.exponent( 3.14e-307 )\n -1019\n > exponent = base.exponent( -3.14 )\n 1\n > exponent = base.exponent( 0.0 )\n -1023\n > exponent = base.exponent( NaN )\n 1024\n\n See Also\n --------\n base.exponentf\n"
+base.exponentf,"\nbase.exponentf( x )\n Returns an integer corresponding to the unbiased exponent of a single-\n precision floating-point number.\n\n Parameters\n ----------\n x: float\n Single-precision floating-point number.\n\n Returns\n -------\n out: integer\n Unbiased exponent.\n\n Examples\n --------\n > var exponent = base.exponentf( base.float64ToFloat32( 3.14e34 ) )\n 114\n > exponent = base.exponentf( base.float64ToFloat32( 3.14e-34 ) )\n -112\n > exponent = base.exponentf( base.float64ToFloat32( -3.14 ) )\n 1\n > exponent = base.exponentf( 0.0 )\n -127\n > exponent = base.exponentf( NaN )\n 128\n\n See Also\n --------\n base.exponent\n"
+base.factorial,"\nbase.factorial( x )\n Evaluates the factorial of `x`.\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 Factorial.\n\n Examples\n --------\n > var y = base.factorial( 3.0 )\n 6.0\n > y = base.factorial( -1.5 )\n ~-3.545\n > y = base.factorial( -0.5 )\n ~1.772\n > y = base.factorial( 0.5 )\n ~0.886\n > y = base.factorial( -10.0 )\n NaN\n > y = base.factorial( 171.0 )\n Infinity\n > y = base.factorial( NaN )\n NaN\n\n See Also\n --------\n base.factorialln\n"
+base.factorialln,"\nbase.factorialln( x )\n Evaluates the natural logarithm of the factorial of `x`.\n\n For input values other than negative integers, the function returns\n\n ln( x! ) = ln( Γ(x+1) )\n\n where `Γ` is the Gamma function. For negative integers, the function returns\n `NaN`.\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 Natural logarithm of the factorial of `x`.\n\n Examples\n --------\n > var y = base.factorialln( 3.0 )\n ~1.792\n > y = base.factorialln( 2.4 )\n ~1.092\n > y = base.factorialln( -1.0 )\n NaN\n > y = base.factorialln( -1.5 )\n ~1.266\n > y = base.factorialln( NaN )\n NaN\n\n See Also\n --------\n base.factorial\n"
+base.fallingFactorial,"\nbase.fallingFactorial( x, n )\n Computes the falling factorial of `x` and `n`.\n\n If not provided a nonnegative integer for `n`, 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 n: integer\n Second function parameter.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var v = base.fallingFactorial( 0.9, 5 )\n ~0.644\n > v = base.fallingFactorial( -9.0, 3 )\n -990.0\n > v = base.fallingFactorial( 0.0, 2 )\n 0.0\n > v = base.fallingFactorial( 3.0, -2 )\n NaN\n\n See Also\n --------\n base.risingFactorial\n"
+base.fibonacci,"\nbase.fibonacci( n )\n Computes the nth Fibonacci number.\n\n Fibonacci numbers follow the recurrence relation\n\n F_n = F_{n-1} + F_{n-2}\n\n with seed values F_0 = 0 and F_1 = 1.\n\n If `n` is greater than `78`, the function returns `NaN`, as larger Fibonacci\n numbers cannot be accurately represented due to limitations of double-\n precision floating-point format.\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: integer\n Fibonacci number.\n\n Examples\n --------\n > var y = base.fibonacci( 0 )\n 0\n > y = base.fibonacci( 1 )\n 1\n > y = base.fibonacci( 2 )\n 1\n > y = base.fibonacci( 3 )\n 2\n > y = base.fibonacci( 4 )\n 3\n > y = base.fibonacci( 79 )\n NaN\n > y = base.fibonacci( NaN )\n NaN\n\n See Also\n --------\n base.binet, base.fibonacciIndex, base.lucas, base.negafibonacci\n"
+base.fibonacciIndex,"\nbase.fibonacciIndex( F )\n Computes the Fibonacci number index.\n\n If not provided a nonnegative integer value, the function returns `NaN`.\n\n If provided `F <= 1` or `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n F: integer\n Fibonacci number.\n\n Returns\n -------\n n: number\n Fibonacci number index.\n\n Examples\n --------\n > var n = base.fibonacciIndex( 2 )\n 3\n > n = base.fibonacciIndex( 3 )\n 4\n > n = base.fibonacciIndex( 5 )\n 5\n > n = base.fibonacciIndex( NaN )\n NaN\n > n = base.fibonacciIndex( 1 )\n NaN\n\n See Also\n --------\n base.fibonacci\n"
+base.fibpoly,"\nbase.fibpoly( n, x )\n Evaluates a Fibonacci polynomial.\n\n Parameters\n ----------\n n: integer\n Fibonacci polynomial to evaluate.\n\n x: number\n Value at which to evaluate the Fibonacci polynomial.\n\n Returns\n -------\n out: number\n Evaluated Fibonacci polynomial.\n\n Examples\n --------\n // 2^4 + 3*2^2 + 1\n > var v = base.fibpoly( 5, 2.0 )\n 29.0\n\n\nbase.fibpoly.factory( n )\n Returns a function for evaluating a Fibonacci polynomial.\n\n Parameters\n ----------\n n: integer\n Fibonacci polynomial to evaluate.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a Fibonacci polynomial.\n\n Examples\n --------\n > var polyval = base.fibpoly.factory( 5 );\n\n // 1^4 + 3*1^2 + 1\n > var v = polyval( 1.0 )\n 5.0\n\n // 2^4 + 3*2^2 + 1\n > v = polyval( 2.0 )\n 29.0\n\n See Also\n --------\n base.evalpoly, base.lucaspoly\n"
+base.flipsign,"\nbase.flipsign( x, y )\n Returns a double-precision floating-point number with the magnitude of `x`\n and the sign of `x*y`.\n\n The function only returns `-x` when `y` is a negative number.\n\n According to the IEEE 754 standard, a `NaN` has a biased exponent equal to\n `2047`, a significand greater than `0`, and a sign bit equal to either `1`\n or `0`. In which case, `NaN` may not correspond to just one but many binary\n representations. Accordingly, care should be taken to ensure that `y` is not\n `NaN`, else behavior may be indeterminate.\n\n Parameters\n ----------\n x: number\n Number from which to derive a magnitude.\n\n y: number\n Number from which to derive a sign.\n\n Returns\n -------\n z: number\n Double-precision floating-point number.\n\n Examples\n --------\n > var z = base.flipsign( -3.14, 10.0 )\n -3.14\n > z = base.flipsign( -3.14, -1.0 )\n 3.14\n > z = base.flipsign( 1.0, -0.0 )\n -1.0\n > z = base.flipsign( -3.14, -0.0 )\n 3.14\n > z = base.flipsign( -0.0, 1.0 )\n -0.0\n > z = base.flipsign( 0.0, -1.0 )\n -0.0\n\n See Also\n --------\n base.copysign\n"
+base.float32ToInt32,"\nbase.float32ToInt32( x )\n Converts a single-precision floating-point number to a signed 32-bit\n integer.\n\n Parameters\n ----------\n x: float\n Single-precision floating-point number.\n\n Returns\n -------\n out: integer\n Signed 32-bit integer.\n\n Examples\n --------\n > var y = base.float32ToInt32( base.float64ToFloat32( 4294967295.0 ) )\n -1\n > y = base.float32ToInt32( base.float64ToFloat32( 3.14 ) )\n 3\n > y = base.float32ToInt32( base.float64ToFloat32( -3.14 ) )\n -3\n > y = base.float32ToInt32( base.float64ToFloat32( NaN ) )\n 0\n > y = base.float32ToInt32( FLOAT32_PINF )\n 0\n > y = base.float32ToInt32( FLOAT32_NINF )\n 0\n\n See Also\n --------\n base.float32ToUint32"
+base.float32ToUint32,"\nbase.float32ToUint32( x )\n Converts a single-precision floating-point number to a unsigned 32-bit\n integer.\n\n Parameters\n ----------\n x: float\n Single-precision floating-point number.\n\n Returns\n -------\n out: integer\n Unsigned 32-bit integer.\n\n Examples\n --------\n > var y = base.float32ToUint32( base.float64ToFloat32( 4294967297.0 ) )\n 1\n > y = base.float32ToUint32( base.float64ToFloat32( 3.14 ) )\n 3\n > y = base.float32ToUint32( base.float64ToFloat32( -3.14 ) )\n 4294967293\n > y = base.float32ToUint32( base.float64ToFloat32( NaN ) )\n 0\n > y = base.float32ToUint32( FLOAT32_PINF )\n 0\n > y = base.float32ToUint32( FLOAT32_NINF )\n 0\n\n See Also\n --------\n base.float32ToInt32"
+base.float64ToFloat32,"\nbase.float64ToFloat32( x )\n Converts a double-precision floating-point number to the nearest single-\n precision floating-point number.\n\n Parameters\n ----------\n x: number\n Double-precision floating-point number.\n\n Returns\n -------\n out: float\n Nearest single-precision floating-point number.\n\n Examples\n --------\n > var y = base.float64ToFloat32( 1.337 )\n 1.3370000123977661\n"
+base.float64ToInt32,"\nbase.float64ToInt32( x )\n Converts a double-precision floating-point number to a signed 32-bit\n integer.\n\n Parameters\n ----------\n x: number\n Double-precision floating-point number.\n\n Returns\n -------\n out: integer\n Signed 32-bit integer.\n\n Examples\n --------\n > var y = base.float64ToInt32( 4294967295.0 )\n -1\n > y = base.float64ToInt32( 3.14 )\n 3\n > y = base.float64ToInt32( -3.14 )\n -3\n > y = base.float64ToInt32( NaN )\n 0\n > y = base.float64ToInt32( PINF )\n 0\n > y = base.float64ToInt32( NINF )\n 0\n\n See Also\n --------\n base.float64ToUint32"
+base.float64ToUint32,"\nbase.float64ToUint32( x )\n Converts a double-precision floating-point number to a unsigned 32-bit\n integer.\n\n Parameters\n ----------\n x: number\n Double-precision floating-point number.\n\n Returns\n -------\n out: integer\n Unsigned 32-bit integer.\n\n Examples\n --------\n > var y = base.float64ToUint32( 4294967297.0 )\n 1\n > y = base.float64ToUint32( 3.14 )\n 3\n > y = base.float64ToUint32( -3.14 )\n 4294967293\n > y = base.float64ToUint32( NaN )\n 0\n > y = base.float64ToUint32( PINF )\n 0\n > y = base.float64ToUint32( NINF )\n 0\n\n See Also\n --------\n base.float64ToInt32"
+base.floor,"\nbase.floor( x )\n Rounds a numeric value toward negative 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.floor( 3.14 )\n 3.0\n > y = base.floor( -4.2 )\n -5.0\n > y = base.floor( -4.6 )\n -5.0\n > y = base.floor( 9.5 )\n 9.0\n > y = base.floor( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceil, base.round\n"
+base.floor2,"\nbase.floor2( x )\n Rounds a numeric value to the nearest power of two toward negative 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.floor2( 3.14 )\n 2.0\n > y = base.floor2( -4.2 )\n -8.0\n > y = base.floor2( -4.6 )\n -8.0\n > y = base.floor2( 9.5 )\n 8.0\n > y = base.floor2( 13.0 )\n 8.0\n > y = base.floor2( -13.0 )\n -16.0\n > y = base.floor2( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceil2, base.floor, base.floor10, base.round2\n"
+base.floor10,"\nbase.floor10( x )\n Rounds a numeric value to the nearest power of ten toward negative 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.floor10( 3.14 )\n 1.0\n > y = base.floor10( -4.2 )\n -10.0\n > y = base.floor10( -4.6 )\n -10.0\n > y = base.floor10( 9.5 )\n 1.0\n > y = base.floor10( 13.0 )\n 10.0\n > y = base.floor10( -13.0 )\n -100.0\n > y = base.floor10( -0.0 )\n -0.0\n\n See Also\n --------\n base.ceil10, base.floor, base.floor2, base.round10\n"
+base.floorb,"\nbase.floorb( x, n, b )\n Rounds a numeric value to the nearest multiple of `b^n` toward negative\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.floorb( 3.14159, -4, 10 )\n 3.1415\n\n // If `n = 0` or `b = 1`, standard round behavior:\n > y = base.floorb( 3.14159, 0, 2 )\n 3.0\n\n // Round to nearest multiple of two toward negative infinity:\n > y = base.floorb( 5.0, 1, 2 )\n 4.0\n\n See Also\n --------\n base.ceilb, base.floor, base.floorn, base.roundb\n"
+base.floorn,"\nbase.floorn( x, n )\n Rounds a numeric value to the nearest multiple of `10^n` toward negative\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 4 decimal places:\n > var y = base.floorn( 3.14159, -4 )\n 3.1415\n\n // If `n = 0`, standard round toward negative infinity behavior:\n > y = base.floorn( 3.14159, 0 )\n 3.0\n\n // Round to nearest thousand:\n > y = base.floorn( 12368.0, 3 )\n 12000.0\n\n\n See Also\n --------\n base.ceiln, base.floor, base.floorb, base.roundn\n"
+base.floorsd,"\nbase.floorsd( x, n[, b] )\n Rounds a numeric value to the nearest number toward negative 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 (optional)\n Base. Must be greater than 0. Default: 10.\n\n Returns\n -------\n y: number\n Rounded value.\n\n Examples\n --------\n > var y = base.floorsd( 3.14159, 5 )\n 3.1415\n > y = base.floorsd( 3.14159, 1 )\n 3.0\n > y = base.floorsd( 12368.0, 2 )\n 12000.0\n > y = base.floorsd( 0.0313, 2, 2 )\n 0.03125\n\n See Also\n --------\n base.ceilsd, base.floor, base.roundsd, base.truncsd\n"
+base.fresnel,"\nbase.fresnel( [out,] x )\n Computes the Fresnel integrals S(x) and C(x).\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Destination array.\n\n x: number\n Input value.\n\n Returns\n -------\n y: Array|TypedArray|Object\n S(x) and C(x).\n\n Examples\n --------\n > var y = base.fresnel( 0.0 )\n [ ~0.0, ~0.0 ]\n > y = base.fresnel( 1.0 )\n [ ~0.438, ~0.780 ]\n > y = base.fresnel( PINF )\n [ ~0.5, ~0.5 ]\n > y = base.fresnel( NINF )\n [ ~-0.5, ~-0.5 ]\n > y = base.fresnel( NaN )\n [ NaN, NaN ]\n\n > var out = new Float64Array( 2 );\n > var v = base.fresnel( out, 0.0 )\n [ ~0.0, ~0.0 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.fresnelc, base.fresnels\n"
+base.fresnelc,"\nbase.fresnelc( x )\n Computes the Fresnel integral C(x).\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n C(x).\n\n Examples\n --------\n > var y = base.fresnelc( 0.0 )\n ~0.0\n > y = base.fresnelc( 1.0 )\n ~0.780\n > y = base.fresnelc( PINF )\n ~0.5\n > y = base.fresnelc( NINF )\n ~-0.5\n > y = base.fresnelc( NaN )\n NaN\n\n See Also\n --------\n base.fresnel, base.fresnels\n"
+base.fresnels,"\nbase.fresnels( x )\n Computes the Fresnel integral S(x).\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n S(x).\n\n Examples\n --------\n > var y = base.fresnels( 0.0 )\n ~0.0\n > y = base.fresnels( 1.0 )\n ~0.438\n > y = base.fresnels( PINF )\n ~0.5\n > y = base.fresnels( NINF )\n ~-0.5\n > y = base.fresnels( NaN )\n NaN\n\n See Also\n --------\n base.fresnel, base.fresnelc\n"
+base.frexp,"\nbase.frexp( [out,] x )\n Splits a double-precision floating-point number into a normalized fraction\n and an integer power of two.\n\n The first element of the returned array is the normalized fraction and the\n second is the exponent. The normalized fraction and exponent satisfy the\n relation\n\n x = frac * 2^exp\n\n If provided positive or negative zero, `NaN`, or positive or negative\n infinity, the function returns a two-element array containing the input\n value and an exponent equal to zero.\n\n For all other numeric input values, the absolute value of the normalized\n fraction resides on the interval [0.5,1).\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n x: number\n Input value.\n\n Returns\n -------\n out: Array|TypedArray|Object\n A normalized fraction and an exponent.\n\n Examples\n --------\n > var out = base.frexp( 4.0 )\n [ 0.5, 3 ]\n > out = base.frexp( 0.0 )\n [ 0.0, 0 ]\n > out = base.frexp( -0.0 )\n [ -0.0, 0 ]\n > out = base.frexp( NaN )\n [ NaN, 0 ]\n > out = base.frexp( PINF )\n [ Infinity, 0 ]\n > out = base.frexp( NINF )\n [ -Infinity, 0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var y = base.frexp( out, 4.0 )\n [ 0.5, 3 ]\n > var bool = ( y === out )\n true\n\n See Also\n --------\n base.ldexp\n"
+base.fromBinaryString,"\nbase.fromBinaryString( bstr )\n Creates a double-precision floating-point number from a literal bit\n representation.\n\n Parameters\n ----------\n bstr: string\n Literal bit representation.\n\n Returns\n -------\n out: number\n Double-precision floating-point number.\n\n Examples\n --------\n > var bstr;\n > bstr = '0100000000010000000000000000000000000000000000000000000000000000';\n > var val = base.fromBinaryString( bstr )\n 4.0\n > bstr = '0100000000001001001000011111101101010100010001000010110100011000';\n > val = base.fromBinaryString( bstr )\n 3.141592653589793\n > bstr = '1111111111100001110011001111001110000101111010111100100010100000';\n > val = base.fromBinaryString( bstr )\n -1.0e308\n\n // The function handles subnormals:\n > bstr = '1000000000000000000000000000000000000000000000000001100011010011';\n > val = base.fromBinaryString( bstr )\n -3.14e-320\n > bstr = '0000000000000000000000000000000000000000000000000000000000000001';\n > val = base.fromBinaryString( bstr )\n 5.0e-324\n\n // The function handles special values:\n > bstr = '0000000000000000000000000000000000000000000000000000000000000000';\n > val = base.fromBinaryString( bstr )\n 0.0\n > bstr = '1000000000000000000000000000000000000000000000000000000000000000';\n > val = base.fromBinaryString( bstr )\n -0.0\n > bstr = '0111111111111000000000000000000000000000000000000000000000000000';\n > val = base.fromBinaryString( bstr )\n NaN\n > bstr = '0111111111110000000000000000000000000000000000000000000000000000';\n > val = base.fromBinaryString( bstr )\n Infinity\n > bstr = '1111111111110000000000000000000000000000000000000000000000000000';\n > val = base.fromBinaryString( bstr )\n -Infinity\n\n See Also\n --------\n base.fromBinaryStringf, base.toBinaryString\n"
+base.fromBinaryStringf,"\nbase.fromBinaryStringf( bstr )\n Creates a single-precision floating-point number from an IEEE 754 literal\n bit representation.\n\n Parameters\n ----------\n bstr: string\n Literal bit representation.\n\n Returns\n -------\n out: float\n Single-precision floating-point number.\n\n Examples\n --------\n > var bstr = '01000000100000000000000000000000';\n > var val = base.fromBinaryStringf( bstr )\n 4.0\n > bstr = '01000000010010010000111111011011';\n > val = base.fromBinaryStringf( bstr )\n ~3.14\n > bstr = '11111111011011000011101000110011';\n > val = base.fromBinaryStringf( bstr )\n ~-3.14e+38\n\n // The function handles subnormals:\n > bstr = '10000000000000000000000000010110';\n > val = base.fromBinaryStringf( bstr )\n ~-3.08e-44\n > bstr = '00000000000000000000000000000001';\n > val = base.fromBinaryStringf( bstr )\n ~1.40e-45\n\n // The function handles special values:\n > bstr = '00000000000000000000000000000000';\n > val = base.fromBinaryStringf( bstr )\n 0.0\n > bstr = '10000000000000000000000000000000';\n > val = base.fromBinaryStringf( bstr )\n -0.0\n > bstr = '01111111110000000000000000000000';\n > val = base.fromBinaryStringf( bstr )\n NaN\n > bstr = '01111111100000000000000000000000';\n > val = base.fromBinaryStringf( bstr )\n Infinity\n > bstr = '11111111100000000000000000000000';\n > val = base.fromBinaryStringf( bstr )\n -Infinity\n\n See Also\n --------\n base.toBinaryStringf, base.fromBinaryString\n"
+base.fromBinaryStringUint8,"\nbase.fromBinaryStringUint8( bstr )\n Creates an unsigned 8-bit integer from a literal bit representation.\n\n Parameters\n ----------\n bstr: string\n Literal bit representation.\n\n Returns\n -------\n out: integer\n Unsigned 8-bit integer.\n\n Examples\n --------\n > var bstr = '01010101';\n > var val = base.fromBinaryStringUint8( bstr )\n 85\n > bstr = '00000000';\n > val = base.fromBinaryStringUint8( bstr )\n 0\n > bstr = '00000010';\n > val = base.fromBinaryStringUint8( bstr )\n 2\n > bstr = '11111111';\n > val = base.fromBinaryStringUint8( bstr )\n 255\n\n See Also\n --------\n base.fromBinaryStringUint16, base.fromBinaryStringUint32, base.toBinaryStringUint8\n"
+base.fromBinaryStringUint16,"\nbase.fromBinaryStringUint16( bstr )\n Creates an unsigned 16-bit integer from a literal bit representation.\n\n Parameters\n ----------\n bstr: string\n Literal bit representation.\n\n Returns\n -------\n out: integer\n Unsigned 16-bit integer.\n\n Examples\n --------\n > var bstr = '0101010101010101';\n > var val = base.fromBinaryStringUint16( bstr )\n 21845\n > bstr = '0000000000000000';\n > val = base.fromBinaryStringUint16( bstr )\n 0\n > bstr = '0000000000000010';\n > val = base.fromBinaryStringUint16( bstr )\n 2\n > bstr = '1111111111111111';\n > val = base.fromBinaryStringUint16( bstr )\n 65535\n\n See Also\n --------\n base.toBinaryStringUint16, base.fromBinaryStringUint32, base.fromBinaryStringUint8\n"
+base.fromBinaryStringUint32,"\nbase.fromBinaryStringUint32( bstr )\n Creates an unsigned 32-bit integer from a literal bit representation.\n\n Parameters\n ----------\n bstr: string\n Literal bit representation.\n\n Returns\n -------\n out: integer\n Unsigned 32-bit integer.\n\n Examples\n --------\n > var bstr = '01010101010101010101010101010101';\n > var val = base.fromBinaryStringUint32( bstr )\n 1431655765\n > bstr = '00000000000000000000000000000000';\n > val = base.fromBinaryStringUint32( bstr )\n 0\n > bstr = '00000000000000000000000000000010';\n > val = base.fromBinaryStringUint32( bstr )\n 2\n > bstr = '11111111111111111111111111111111';\n > val = base.fromBinaryStringUint32( bstr )\n 4294967295\n\n See Also\n --------\n base.fromBinaryStringUint16, base.toBinaryStringUint32, base.fromBinaryStringUint8\n"
+base.fromWordf,"\nbase.fromWordf( x )\n Creates a single-precision floating-point number from an unsigned integer\n corresponding to an IEEE 754 binary representation.\n\n Parameters\n ----------\n x: integer\n Unsigned integer.\n\n Returns\n -------\n out: float\n Single-precision floating-point number.\n\n Examples\n --------\n > var word = 1068180177; // => 0 01111111 01010110010001011010001\n > var f32 = base.fromWordf( word ) // when printed, promoted to float64\n 1.3370000123977661\n\n See Also\n --------\n base.fromWords\n"
+base.fromWords,"\nbase.fromWords( high, low )\n Creates a double-precision floating-point number from a higher order word\n (unsigned 32-bit integer) and a lower order word (unsigned 32-bit integer).\n\n Parameters\n ----------\n high: integer\n Higher order word (unsigned 32-bit integer).\n\n low: integer\n Lower order word (unsigned 32-bit integer).\n\n Returns\n -------\n out: number\n Double-precision floating-point number.\n\n Examples\n --------\n > var v = base.fromWords( 1774486211, 2479577218 )\n 3.14e201\n > v = base.fromWords( 3221823995, 1413754136 )\n -3.141592653589793\n > v = base.fromWords( 0, 0 )\n 0.0\n > v = base.fromWords( 2147483648, 0 )\n -0.0\n > v = base.fromWords( 2146959360, 0 )\n NaN\n > v = base.fromWords( 2146435072, 0 )\n Infinity\n > v = base.fromWords( 4293918720, 0 )\n -Infinity\n\n See Also\n --------\n base.fromWordf\n"
+base.gamma,"\nbase.gamma( x )\n Evaluates the gamma function.\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.gamma( 4.0 )\n 6.0\n > y = base.gamma( -1.5 )\n ~2.363\n > y = base.gamma( -0.5 )\n ~-3.545\n > y = base.gamma( 0.5 )\n ~1.772\n > y = base.gamma( 0.0 )\n Infinity\n > y = base.gamma( -0.0 )\n -Infinity\n > y = base.gamma( NaN )\n NaN\n\n See Also\n --------\n base.gamma1pm1, base.gammainc, base.gammaincinv, base.gammaln\n"
+base.gamma1pm1,"\nbase.gamma1pm1( x )\n Computes `gamma(x+1) - 1` without cancellation errors, where `gamma(x)` is\n the gamma function.\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.gamma1pm1( 0.2 )\n ~-0.082\n > y = base.gamma1pm1( -6.7 )\n ~-0.991\n > y = base.gamma1pm1( 0.0 )\n 0.0\n > y = base.gamma1pm1( NaN )\n NaN\n\n See Also\n --------\n base.gamma, base.gammainc, base.gammaincinv, base.gammaln\n"
+base.gammaDeltaRatio,"\nbase.gammaDeltaRatio( z, delta )\n Computes the ratio of two gamma functions.\n\n The ratio is defined as: Γ(z) / Γ(z+Δ).\n\n Parameters\n ----------\n z: number\n First gamma parameter.\n\n delta: number\n Difference.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.gammaDeltaRatio( 2.0, 3.0 )\n ~0.042\n > y = base.gammaDeltaRatio( 4.0, 0.5 )\n ~0.516\n > y = base.gammaDeltaRatio( 100.0, 0.0 )\n 1.0\n > y = base.gammaDeltaRatio( NaN, 3.0 )\n NaN\n > y = base.gammaDeltaRatio( 5.0, NaN )\n NaN\n > y = base.gammaDeltaRatio( NaN, NaN )\n NaN\n\n See Also\n --------\n base.gamma\n"
+base.gammainc,"\nbase.gammainc( x, s[, regularized[, upper]] )\n Computes the regularized incomplete gamma function.\n\n The `regularized` and `upper` parameters specify whether to evaluate the\n non-regularized and/or upper incomplete gamma functions, respectively.\n\n If provided `x < 0` or `s <= 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 s: number\n Second function parameter.\n\n regularized: boolean (optional)\n Boolean indicating whether the function should evaluate the regularized\n or non-regularized incomplete gamma function. Default: `true`.\n\n upper: boolean (optional)\n Boolean indicating whether the function should return the upper tail of\n the incomplete gamma function. Default: `false`.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.gammainc( 6.0, 2.0 )\n ~0.9826\n > y = base.gammainc( 1.0, 2.0, true, true )\n ~0.7358\n > y = base.gammainc( 7.0, 5.0 )\n ~0.8270\n > y = base.gammainc( 7.0, 5.0, false )\n ~19.8482\n > y = base.gammainc( NaN, 2.0 )\n NaN\n > y = base.gammainc( 6.0, NaN )\n NaN\n\n See Also\n --------\n base.gamma, base.gamma1pm1, base.gammaincinv, base.gammaln\n"
+base.gammaincinv,"\nbase.gammaincinv( p, a[, upper] )\n Computes the inverse of the lower incomplete gamma function.\n\n In contrast to a more commonly used definition, the first argument is the\n probability `p` and the second argument is the scale factor `a`.\n\n By default, the function inverts the lower regularized incomplete gamma\n function, `P(x,a)`. To invert the upper function `Q(x,a)`, set the `upper`\n 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 Parameters\n ----------\n p: number\n Probability.\n\n a: number\n Scale parameter.\n\n upper: boolean (optional)\n Boolean indicating if the function should invert the upper tail of the\n incomplete gamma function; i.e., compute `xr` such that `Q(a,xr) = p`.\n Default: `false`.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.gammaincinv( 0.5, 2.0 )\n ~1.678\n > y = base.gammaincinv( 0.1, 10.0 )\n ~6.221\n > y = base.gammaincinv( 0.75, 3.0 )\n ~3.92\n > y = base.gammaincinv( 0.75, 3.0, true )\n ~1.727\n > y = base.gammaincinv( 0.75, NaN )\n NaN\n > y = base.gammaincinv( NaN, 3.0 )\n NaN\n\n See Also\n --------\n base.gamma, base.gamma1pm1, base.gammainc, base.gammaln\n"
+base.gammaLanczosSum,"\nbase.gammaLanczosSum( x )\n Calculates the Lanczos sum for the approximation of the gamma function.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Lanczos sum.\n\n Examples\n --------\n > var y = base.gammaLanczosSum( 4.0 )\n ~950.366\n > y = base.gammaLanczosSum( -1.5 )\n ~1373366.245\n > y = base.gammaLanczosSum( -0.5 )\n ~-699841.735\n > y = base.gammaLanczosSum( 0.5 )\n ~96074.186\n > y = base.gammaLanczosSum( 0.0 )\n Infinity\n > y = base.gammaLanczosSum( NaN )\n NaN\n\n See Also\n --------\n base.gamma, base.gammaLanczosSumExpGScaled\n"
+base.gammaLanczosSumExpGScaled,"\nbase.gammaLanczosSumExpGScaled( x )\n Calculates the scaled Lanczos sum for the approximation of the gamma\n function.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Scaled Lanczos sum.\n\n Examples\n --------\n > var y = base.gammaLanczosSumExpGScaled( 4.0 )\n ~0.018\n > y = base.gammaLanczosSumExpGScaled( -1.5 )\n ~25.337\n > y = base.gammaLanczosSumExpGScaled( -0.5 )\n ~-12.911\n > y = base.gammaLanczosSumExpGScaled( 0.5 )\n ~1.772\n > y = base.gammaLanczosSumExpGScaled( 0.0 )\n Infinity\n > y = base.gammaLanczosSumExpGScaled( NaN )\n NaN\n\n See Also\n --------\n base.gamma, base.gammaLanczosSum\n"
+base.gammaln,"\nbase.gammaln( x )\n Evaluates the natural logarithm of the gamma function.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Natural logarithm of the gamma function.\n\n Examples\n --------\n > var y = base.gammaln( 1.0 )\n 0.0\n > y = base.gammaln( 2.0 )\n 0.0\n > y = base.gammaln( 4.0 )\n ~1.792\n > y = base.gammaln( -0.5 )\n ~1.266\n > y = base.gammaln( 0.5 )\n ~0.572\n > y = base.gammaln( 0.0 )\n Infinity\n > y = base.gammaln( NaN )\n NaN\n\n See Also\n --------\n base.gamma, base.gammainc, base.gammaincinv\n"
+base.gasum,"\nbase.gasum( N, x, stride )\n Computes the sum of the absolute values.\n\n The sum of absolute values corresponds to the *L1* norm.\n\n The `N` and `stride` parameters determine which elements in `x` are used to\n compute the sum.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n If `N` or `stride` is less than or equal to `0`, the function returns `0`.\n\n Parameters\n ----------\n N: integer\n Number of elements to sum.\n\n x: Array|TypedArray\n Input array.\n\n stride: integer\n Index increment.\n\n Returns\n -------\n sum: number\n Sum of absolute values.\n\n Examples\n --------\n // Standard usage:\n > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];\n > var sum = base.gasum( x.length, x, 1 )\n 19.0\n\n // Sum every other value:\n > var N = base.floor( x.length / 2 );\n > var stride = 2;\n > sum = base.gasum( N, x, stride )\n 10.0\n\n // Use view offset; e.g., starting at 2nd element:\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 > N = base.floor( x0.length / 2 );\n > sum = base.gasum( N, x1, stride )\n 12.0\n\n\nbase.gasum.ndarray( N, x, stride, offset )\n Computes the sum of absolute values 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 elements to sum.\n\n x: Array|TypedArray\n Input array.\n\n stride: integer\n Index increment.\n\n offset: integer\n Starting index.\n\n Returns\n -------\n sum: number\n Sum of absolute values.\n\n Examples\n --------\n // Standard usage:\n > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];\n > var sum = base.gasum.ndarray( x.length, x, 1, 0 )\n 19.0\n\n // Sum the last three elements:\n > x = [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ];\n > sum = base.gasum.ndarray( 3, x, -1, x.length-1 )\n 15.0\n\n See Also\n --------\n base.dasum, base.sasum\n"
+base.gaxpy,"\nbase.gaxpy( N, alpha, x, strideX, y, strideY )\n Multiplies `x` by a constant `alpha` and adds the result to `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 If `N <= 0` or `alpha == 0`, the function returns `y` unchanged.\n\n Parameters\n ----------\n N: integer\n Number of indexed elements.\n\n alpha: number\n Constant.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n y: Array|TypedArray\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n Returns\n -------\n y: Array|TypedArray\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\n > var y = [ 1.0, 1.0, 1.0, 1.0, 1.0 ];\n > var alpha = 5.0;\n > base.gaxpy( x.length, alpha, x, 1, y, 1 )\n [ 6.0, 11.0, 16.0, 21.0, 26.0 ]\n\n // Using `N` and `stride` parameters:\n > var N = base.floor( x.length / 2 );\n > base.gaxpy( N, alpha, x, 2, y, -1 )\n [ 26.0, 16.0, 6.0, 1.0, 1.0, 1.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 y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\n > N = base.floor( x0.length / 2 );\n > base.gaxpy( N, 5.0, x1, -2, y1, 1 )\n [ 40.0, 33.0, 22.0 ]\n > y0\n [ 7.0, 8.0, 9.0, 40.0, 31.0, 22.0 ]\n\n\nbase.gaxpy.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY )\n Multiplies `x` by a constant `alpha` and adds the result to `y`, with\n 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 alpha: number\n Constant.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Array|TypedArray\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: Array|TypedArray\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\n > var y = [ 1.0, 1.0, 1.0, 1.0, 1.0 ];\n > var alpha = 5.0;\n > base.gaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 )\n [ 6.0, 11.0, 16.0, 21.0, 26.0 ]\n\n // Advanced indexing:\n > x = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\n > y = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\n > var N = base.floor( x.length / 2 );\n > base.gaxpy.ndarray( N, alpha, x, 2, 1, y, -1, y.length-1 )\n [ 7.0, 8.0, 9.0, 40.0, 31.0, 22.0 ]\n\n See Also\n --------\n base.daxpy, base.saxpy\n"
+base.gcd,"\nbase.gcd( a, b )\n Computes the greatest common divisor (gcd).\n\n If both `a` and `b` are `0`, the function returns `0`.\n\n Both `a` and `b` must have integer values; otherwise, the function returns\n `NaN`.\n\n Parameters\n ----------\n a: integer\n First integer.\n\n b: integer\n Second integer.\n\n Returns\n -------\n out: integer\n Greatest common divisor.\n\n Examples\n --------\n > var v = base.gcd( 48, 18 )\n 6\n\n See Also\n --------\n base.lcm\n"
+base.gcopy,"\nbase.gcopy( N, x, strideX, y, strideY )\n Copies values from `x` into `y`.\n\n The `N` and `stride` parameters determine how values from `x` are copied\n into `y`.\n\n Indexing is relative to the first index. To introduce an offset, use typed\n array views.\n\n If `N` is less than or equal to `0`, the function returns `y` unchanged.\n\n Parameters\n ----------\n N: integer\n Number of values to copy.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n y: Array|TypedArray\n Destination array.\n\n strideY: integer\n Index increment for `y`.\n\n Returns\n -------\n y: Array|TypedArray\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\n > var y = [ 6.0, 7.0, 8.0, 9.0, 10.0 ];\n > base.gcopy( x.length, x, 1, y, 1 )\n [ 1.0, 2.0, 3.0, 4.0, 5.0 ]\n\n // Advanced indexing:\n > x = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\n > y = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\n > var N = base.floor( x.length / 2 );\n > base.gcopy( N, x, -2, y, 1 )\n [ 5.0, 3.0, 1.0, 10.0, 11.0, 12.0 ]\n\n // Using typed array views:\n > var x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n > var y0 = new Float64Array( [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );\n > var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 );\n > var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 );\n > N = base.floor( x0.length / 2 );\n > base.gcopy( N, x1, -2, y1, 1 )\n [ 6.0, 4.0, 2.0 ]\n > y0\n [ 7.0, 8.0, 9.0, 6.0, 4.0, 2.0 ]\n\n\nbase.gcopy.ndarray( N, x, strideX, offsetX, y, strideY, offsetY )\n Copies values from `x` into `y`, with alternative indexing semantics.\n\n While typed array views mandate a view offset based on the underlying\n buffer, the `offset` parameters support indexing semantics based on starting\n indices.\n\n Parameters\n ----------\n N: integer\n Number of values to copy.\n\n x: Array|TypedArray\n Input array.\n\n strideX: integer\n Index increment for `x`.\n\n offsetX: integer\n Starting index for `x`.\n\n y: Array|TypedArray\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: Array|TypedArray\n Input array `y`.\n\n Examples\n --------\n // Standard usage:\n > var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];\n > var y = [ 6.0, 7.0, 8.0, 9.0, 10.0 ];\n > base.gcopy.ndarray( x.length, x, 1, 0, y, 1, 0 )\n [ 1.0, 2.0, 3.0, 4.0, 5.0 ]\n\n // Advanced indexing:\n > x = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];\n > y = [ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ];\n > var N = base.floor( x.length / 2 );\n > base.gcopy.ndarray( N, x, 2, 1, y, -1, y.length-1 )\n [ 7.0, 8.0, 9.0, 6.0, 4.0, 2.0 ]\n\n See Also\n --------\n base.dcopy\n"
+base.getHighWord,"\nbase.getHighWord( x )\n Returns an unsigned 32-bit integer corresponding to the more significant 32\n bits of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n out: integer\n Higher order word (unsigned 32-bit integer).\n\n Examples\n --------\n > var w = base.getHighWord( 3.14e201 )\n 1774486211\n\n See Also\n --------\n base.getLowWord, base.setHighWord\n"
+base.getLowWord,"\nbase.getLowWord( x )\n Returns an unsigned 32-bit integer corresponding to the less significant 32\n bits of a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n out: integer\n Lower order word (unsigned 32-bit integer).\n\n Examples\n --------\n > var w = base.getLowWord( 3.14e201 )\n 2479577218\n\n See Also\n --------\n base.getHighWord, base.setHighWord\n"
+base.hacovercos,"\nbase.hacovercos( x )\n Computes the half-value coversed cosine.\n\n The half-value coversed cosine is defined as `(1 + sin(x)) / 2`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Half-value coversed cosine.\n\n Examples\n --------\n > var y = base.hacovercos( 3.14 )\n ~0.5008\n > y = base.hacovercos( -4.2 )\n ~0.9358\n > y = base.hacovercos( -4.6 )\n ~0.9968\n > y = base.hacovercos( 9.5 )\n ~0.4624\n > y = base.hacovercos( -0.0 )\n 0.5\n\n See Also\n --------\n base.hacoversin, base.havercos\n"
+base.hacoversin,"\nbase.hacoversin( x )\n Computes the half-value coversed sine.\n\n The half-value coversed sine is defined as `(1 - sin(x)) / 2`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Half-value coversed sine.\n\n Examples\n --------\n > var y = base.hacoversin( 3.14 )\n ~0.4992\n > y = base.hacoversin( -4.2 )\n ~0.0642\n > y = base.hacoversin( -4.6 )\n ~0.0032\n > y = base.hacoversin( 9.5 )\n ~0.538\n > y = base.hacoversin( -0.0 )\n 0.5\n\n See Also\n --------\n base.hacovercos, base.haversin\n"
+base.havercos,"\nbase.havercos( x )\n Computes the half-value versed cosine.\n\n The half-value versed cosine is defined as `(1 + cos(x)) / 2`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Half-value versed cosine.\n\n Examples\n --------\n > var y = base.havercos( 3.14 )\n ~0.0\n > y = base.havercos( -4.2 )\n ~0.2549\n > y = base.havercos( -4.6 )\n ~0.4439\n > y = base.havercos( 9.5 )\n ~0.0014\n > y = base.havercos( -0.0 )\n 1.0\n\n See Also\n --------\n base.haversin, base.vercos\n"
+base.haversin,"\nbase.haversin( x )\n Computes the half-value versed sine.\n\n The half-value versed sine is defined as `(1 - cos(x)) / 2`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n Returns\n -------\n y: number\n Half-value versed sine.\n\n Examples\n --------\n > var y = base.haversin( 3.14 )\n ~1.0\n > y = base.haversin( -4.2 )\n ~0.7451\n > y = base.haversin( -4.6 )\n ~0.5561\n > y = base.haversin( 9.5 )\n ~0.9986\n > y = base.haversin( -0.0 )\n 0.0\n\n See Also\n --------\n base.havercos, base.versin\n"
+base.heaviside,"\nbase.heaviside( x[, continuity] )\n Evaluates the Heaviside function.\n\n The `continuity` parameter may be one of the following:\n\n - 'half-maximum': if `x == 0`, the function returns `0.5`.\n - 'left-continuous': if `x == 0`, the function returns `0`.\n - 'right-continuous': if `x == 0`, the function returns `1`.\n\n By default, if `x == 0`, the function returns `NaN` (i.e., the function is\n discontinuous).\n\n Parameters\n ----------\n x: number\n Input value.\n\n continuity: string (optional)\n Specifies how to handle `x == 0`. By default, if `x == 0`, the function\n returns `NaN`.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.heaviside( 3.14 )\n 1.0\n > y = base.heaviside( -3.14 )\n 0.0\n > y = base.heaviside( 0.0 )\n NaN\n > y = base.heaviside( 0.0, 'half-maximum' )\n 0.5\n > y = base.heaviside( 0.0, 'left-continuous' )\n 0.0\n > y = base.heaviside( 0.0, 'right-continuous' )\n 1.0\n\n See Also\n --------\n base.ramp\n"
+base.hermitepoly,"\nbase.hermitepoly( n, x )\n Evaluates a physicist's Hermite polynomial.\n\n Parameters\n ----------\n n: integer\n Nonnegative polynomial degree.\n\n x: number\n Value at which to evaluate the polynomial.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.hermitepoly( 1, 0.5 )\n 1.0\n > y = base.hermitepoly( -1, 0.5 )\n NaN\n > y = base.hermitepoly( 0, 0.5 )\n 1.0\n > y = base.hermitepoly( 2, 0.5 )\n -1.0\n\n\nbase.hermitepoly.factory( n )\n Returns a function for evaluating a physicist's Hermite polynomial.\n\n Parameters\n ----------\n n: integer\n Nonnegative polynomial degree.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a physicist's Hermite polynomial.\n\n Examples\n --------\n > var polyval = base.hermitepoly.factory( 2 );\n > var v = polyval( 0.5 )\n -1.0\n\n See Also\n --------\n base.evalpoly, base.normhermitepoly\n"
+base.hypot,"\nbase.hypot( x, y )\n Computes the hypotenuse avoiding overflow and underflow.\n\n If either argument is `NaN`, the function returns `NaN`.\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 Hypotenuse.\n\n Examples\n --------\n > var h = base.hypot( -5.0, 12.0 )\n 13.0\n > h = base.hypot( NaN, 12.0 )\n NaN\n > h = base.hypot( -0.0, -0.0 )\n 0.0\n\n"
+base.imul,"\nbase.imul( a, b )\n Performs C-like multiplication of two signed 32-bit integers.\n\n Parameters\n ----------\n a: integer\n Signed 32-bit integer.\n\n b: integer\n Signed 32-bit integer.\n\n Returns\n -------\n out: integer\n Product.\n\n Examples\n --------\n > var v = base.imul( -10|0, 4|0 )\n -40\n\n See Also\n --------\n base.imuldw, base.uimul\n"
+base.imuldw,"\nbase.imuldw( [out,] a, b )\n Multiplies two signed 32-bit integers and returns an array of two signed 32-\n bit integers which represents the signed 64-bit integer product.\n\n When computing the product of 32-bit integer values in double-precision\n floating-point format (the default JavaScript numeric data type), computing\n the double word product is necessary in order to avoid exceeding the maximum\n safe double-precision floating-point integer value.\n\n Parameters\n ----------\n out: ArrayLikeObject (optional)\n The output array.\n\n a: integer\n Signed 32-bit integer.\n\n b: integer\n Signed 32-bit integer.\n\n Returns\n -------\n out: ArrayLikeObject\n Double word product (in big endian order; i.e., the first element\n corresponds to the most significant bits and the second element to the\n least significant bits).\n\n Examples\n --------\n > var v = base.imuldw( 1, 10 )\n [ 0, 10 ]\n\n See Also\n --------\n base.imul, base.uimuldw\n"
+base.int32ToUint32,"\nbase.int32ToUint32( x )\n Converts a signed 32-bit integer to an unsigned 32-bit integer.\n\n Parameters\n ----------\n x: integer\n Signed 32-bit integer.\n\n Returns\n -------\n out: integer\n Unsigned 32-bit integer.\n\n Examples\n --------\n > var y = base.int32ToUint32( base.float64ToInt32( -32 ) )\n 4294967264\n > y = base.int32ToUint32( base.float64ToInt32( 3 ) )\n 3\n\n See Also\n --------\n base.uint32ToInt32\n"
+base.inv,"\nbase.inv( x )\n Computes the multiplicative inverse of `x`.\n\n The multiplicative inverse is defined as `1/x`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Multiplicative inverse.\n\n Examples\n --------\n > var y = base.inv( -1.0 )\n -1.0\n > y = base.inv( 2.0 )\n 0.5\n > y = base.inv( 0.0 )\n Infinity\n > y = base.inv( -0.0 )\n -Infinity\n > y = base.inv( NaN )\n NaN\n\n See Also\n --------\n base.pow\n"
+base.isEven,"\nbase.isEven( x )\n Tests if a finite numeric value is an even number.\n\n The function assumes a finite number. If provided positive or negative\n infinity, the function will return `true`, when, in fact, the result is\n undefined.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is an even number.\n\n Examples\n --------\n > var bool = base.isEven( 5.0 )\n false\n > bool = base.isEven( -2.0 )\n true\n > bool = base.isEven( 0.0 )\n true\n > bool = base.isEven( NaN )\n false\n\n See Also\n --------\n base.isOdd\n"
+base.isEvenInt32,"\nbase.isEvenInt32( x )\n Tests if a 32-bit integer is even.\n\n Parameters\n ----------\n x: integer\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is an even number.\n\n Examples\n --------\n > var bool = base.isEvenInt32( 5 )\n false\n > bool = base.isEvenInt32( -2 )\n true\n > bool = base.isEvenInt32( 0 )\n true\n\n See Also\n --------\n base.isEven, base.isOddInt32\n"
+base.isFinite,"\nbase.isFinite( x )\n Tests if a numeric value is finite.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is finite.\n\n Examples\n --------\n > var bool = base.isFinite( 5.0 )\n true\n > bool = base.isFinite( -2.0e64 )\n true\n > bool = base.isFinite( PINF )\n false\n > bool = base.isFinite( NINF )\n false\n\n See Also\n --------\n base.isInfinite\n"
+base.isInfinite,"\nbase.isInfinite( x )\n Tests if a numeric value is infinite.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is infinite.\n\n Examples\n --------\n > var bool = base.isInfinite( PINF )\n true\n > bool = base.isInfinite( NINF )\n true\n > bool = base.isInfinite( 5.0 )\n false\n > bool = base.isInfinite( NaN )\n false\n\n See Also\n --------\n base.isFinite\n"
+base.isInteger,"\nbase.isInteger( x )\n Tests if a finite double-precision floating-point number is an integer.\n\n The function assumes a finite number. If provided positive or negative\n infinity, the function will return `true`, when, in fact, the result is\n undefined.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is an integer.\n\n Examples\n --------\n > var bool = base.isInteger( 1.0 )\n true\n > bool = base.isInteger( 3.14 )\n false\n\n"
+base.isnan,"\nbase.isnan( x )\n Tests if a numeric value is `NaN`.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is `NaN`.\n\n Examples\n --------\n > var bool = base.isnan( NaN )\n true\n > bool = base.isnan( 7.0 )\n false\n\n"
+base.isNegativeInteger,"\nbase.isNegativeInteger( x )\n Tests if a finite double-precision floating-point number is a negative\n integer.\n\n The function assumes a finite number. If provided negative infinity, the\n function will return `true`, when, in fact, the result is undefined.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a negative integer.\n\n Examples\n --------\n > var bool = base.isNegativeInteger( -1.0 )\n true\n > bool = base.isNegativeInteger( 0.0 )\n false\n > bool = base.isNegativeInteger( 10.0 )\n false\n\n See Also\n --------\n base.isInteger, base.isNonNegativeInteger, base.isNonPositiveInteger, base.isPositiveInteger\n"
+base.isNegativeZero,"\nbase.isNegativeZero( x )\n Tests if a numeric value is negative zero.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is negative zero.\n\n Examples\n --------\n > var bool = base.isNegativeZero( -0.0 )\n true\n > bool = base.isNegativeZero( 0.0 )\n false\n\n See Also\n --------\n base.isPositiveZero\n"
+base.isNonNegativeInteger,"\nbase.isNonNegativeInteger( x )\n Tests if a finite double-precision floating-point number is a nonnegative\n integer.\n\n The function assumes a finite number. If provided positive infinity, the\n function will return `true`, when, in fact, the result is undefined.\n\n The function does not distinguish between positive and negative zero.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a nonnegative integer.\n\n Examples\n --------\n > var bool = base.isNonNegativeInteger( 1.0 )\n true\n > bool = base.isNonNegativeInteger( 0.0 )\n true\n > bool = base.isNonNegativeInteger( -10.0 )\n false\n\n See Also\n --------\n base.isInteger, base.isNegativeInteger, base.isNonPositiveInteger, base.isPositiveInteger\n"
+base.isNonPositiveInteger,"\nbase.isNonPositiveInteger( x )\n Tests if a finite double-precision floating-point number is a nonpositive\n integer.\n\n The function assumes a finite number. If provided negative infinity, the\n function will return `true`, when, in fact, the result is undefined.\n\n The function does not distinguish between positive and negative zero.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a nonpositive integer.\n\n Examples\n --------\n > var bool = base.isNonPositiveInteger( -1.0 )\n true\n > bool = base.isNonPositiveInteger( 0.0 )\n true\n > bool = base.isNonPositiveInteger( 10.0 )\n false\n\n See Also\n --------\n base.isInteger, base.isNegativeInteger, base.isNonNegativeInteger, base.isPositiveInteger\n"
+base.isOdd,"\nbase.isOdd( x )\n Tests if a finite numeric value is an odd number.\n\n The function assumes a finite number. If provided positive or negative\n infinity, the function will return `true`, when, in fact, the result is\n undefined.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is an odd number.\n\n Examples\n --------\n > var bool = base.isOdd( 5.0 )\n true\n > bool = base.isOdd( -2.0 )\n false\n > bool = base.isOdd( 0.0 )\n false\n > bool = base.isOdd( NaN )\n false\n\n See Also\n --------\n base.isEven\n"
+base.isOddInt32,"\nbase.isOddInt32( x )\n Tests if a 32-bit integer is odd.\n\n Parameters\n ----------\n x: integer\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is an odd number.\n\n Examples\n --------\n > var bool = base.isOddInt32( 5 )\n true\n > bool = base.isOddInt32( -2 )\n false\n > bool = base.isOddInt32( 0 )\n false\n\n See Also\n --------\n base.isEvenInt32, base.isOdd\n"
+base.isPositiveInteger,"\nbase.isPositiveInteger( x )\n Tests if a finite double-precision floating-point number is a positive\n integer.\n\n The function assumes a finite number. If provided positive infinity, the\n function will return `true`, when, in fact, the result is undefined.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a positive integer.\n\n Examples\n --------\n > var bool = base.isPositiveInteger( 1.0 )\n true\n > bool = base.isPositiveInteger( 0.0 )\n false\n > bool = base.isPositiveInteger( -10.0 )\n false\n\n See Also\n --------\n base.isInteger, base.isNegativeInteger, base.isNonNegativeInteger, base.isNonPositiveInteger\n"
+base.isPositiveZero,"\nbase.isPositiveZero( x )\n Tests if a numeric value is positive zero.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is positive zero.\n\n Examples\n --------\n > var bool = base.isPositiveZero( 0.0 )\n true\n > bool = base.isPositiveZero( -0.0 )\n false\n\n See Also\n --------\n base.isNegativeZero\n"
+base.isPow2Uint32,"\nbase.isPow2Uint32( x )\n Tests whether an unsigned integer is a power of 2.\n\n Parameters\n ----------\n x: integer\n Unsigned integer.\n\n Returns\n -------\n bool: boolean\n Boolean indicating if a value is a power of 2.\n\n Examples\n --------\n > var bool = base.isPow2Uint32( 2 )\n true\n > bool = base.isPow2Uint32( 5 )\n false\n\n"
+base.isProbability,"\nbase.isProbability( x )\n Tests if a numeric value is a probability.\n\n A probability is defined as a numeric value on the closed interval `[0,1]`.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a probability.\n\n Examples\n --------\n > var bool = base.isProbability( 0.5 )\n true\n > bool = base.isProbability( 3.14 )\n false\n > bool = base.isProbability( NaN )\n false\n\n"
+base.isSafeInteger,"\nbase.isSafeInteger( x )\n Tests if a finite double-precision floating-point number is a safe integer.\n\n An integer valued number is \"safe\" when the number can be exactly\n represented as a double-precision floating-point number.\n\n Parameters\n ----------\n x: number\n Value to test.\n\n Returns\n -------\n bool: boolean\n Boolean indicating whether the value is a safe integer.\n\n Examples\n --------\n > var bool = base.isSafeInteger( 1.0 )\n true\n > bool = base.isSafeInteger( 2.0e200 )\n false\n > bool = base.isSafeInteger( 3.14 )\n false\n\n"
+base.kernelBetainc,"\nbase.kernelBetainc( [out,] x, a, b, regularized, upper )\n Computes the kernel function for 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, NaN ]`.\n\n If provided `a < 0` or `b < 0`, the function returns `[ NaN, NaN ]`.\n\n If provided `NaN` for `x`, `a`, or `b`, the function returns `[ NaN, NaN ]`.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\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\n Boolean indicating whether the function should evaluate the regularized\n or non-regularized incomplete beta function.\n\n upper: boolean\n Boolean indicating whether the function should return the upper tail of\n the incomplete beta function.\n\n Returns\n -------\n y: Array|TypedArray|Object\n Function value and first derivative.\n\n Examples\n --------\n > var out = base.kernelBetainc( 0.8, 1.0, 0.3, false, false )\n [ ~1.277, ~0.926 ]\n > out = base.kernelBetainc( 0.2, 1.0, 2.0, true, false )\n [ 0.32, 1.6 ]\n\n > out = new Array( 2 );\n > var v = base.kernelBetainc( out, 0.2, 1.0, 2.0, true, true )\n [ 0.64, 1.6 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.betainc\n"
+base.kernelBetaincinv,"\nbase.kernelBetaincinv( a, b, p, q )\n Computes the inverse of the lower incomplete beta function.\n\n Probabilities `p` and `q` must satisfy `p = 1 - q`.\n\n Parameters\n ----------\n a: number\n First function parameter (a positive number).\n\n b: number\n Second function parameter (a positive number).\n\n p: number\n Probability.\n\n q: number\n Probability equal to `1-p`.\n\n Returns\n -------\n out: Array\n Two-element array holding function value `y` and `1-y`.\n\n Examples\n --------\n > var y = base.kernelBetaincinv( 3.0, 3.0, 0.2, 0.8 )\n [ ~0.327, ~0.673 ]\n > y = base.kernelBetaincinv( 3.0, 3.0, 0.4, 0.6 )\n [ ~0.446, ~0.554 ]\n > y = base.kernelBetaincinv( 1.0, 6.0, 0.4, 0.6 )\n [ ~0.082, ~0.918 ]\n > y = base.kernelBetaincinv( 1.0, 6.0, 0.8, 0.2 )\n [ ~0.235, ~0.765 ]\n\n See Also\n --------\n base.betaincinv\n"
+base.kernelCos,"\nbase.kernelCos( x, y )\n Computes the cosine of a number on `[-π/4, π/4]`.\n\n For increased accuracy, the number for which the cosine should be evaluated\n can be supplied as a double-double number (i.e., a non-evaluated sum of two\n double-precision floating-point numbers `x` and `y`).\n\n The two numbers must satisfy `|y| < 0.5 * ulp( x )`.\n\n If either argument is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n y: number\n Tail of `x`.\n\n Returns\n -------\n out: number\n Cosine.\n\n Examples\n --------\n > var out = base.kernelCos( 0.0, 0.0 )\n ~1.0\n > out = base.kernelCos( PI/6.0, 0.0 )\n ~0.866\n > out = base.kernelCos( 0.785, -1.144e-17 )\n ~0.707\n > out = base.kernelCos( NaN )\n NaN\n\n See Also\n --------\n base.cos, base.kernelSin, base.kernelTan\n"
+base.kernelSin,"\nbase.kernelSin( x, y )\n Computes the sine of a number on `[-π/4, π/4]`.\n\n For increased accuracy, the number for which the cosine should be evaluated\n can be supplied as a double-double number (i.e., a non-evaluated sum of two\n double-precision floating-point numbers `x` and `y`).\n\n The two numbers must satisfy `|y| < 0.5 * ulp( x )`.\n\n If either argument is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n y: number\n Tail of `x`.\n\n Returns\n -------\n out: number\n Sine.\n\n Examples\n --------\n > var y = base.kernelSin( 0.0, 0.0 )\n ~0.0\n > y = base.kernelSin( PI/6.0, 0.0 )\n ~0.5\n > y = base.kernelSin( 0.619, 9.279e-18 )\n ~0.58\n\n > y = base.kernelSin( NaN, 0.0 )\n NaN\n > y = base.kernelSin( 2.0, NaN )\n NaN\n > y = base.kernelSin( NaN, NaN )\n NaN\n\n See Also\n --------\n base.kernelCos, base.kernelTan, base.sin\n"
+base.kernelTan,"\nbase.kernelTan( x, y, k )\n Computes the tangent of a number on `[-π/4, π/4]`.\n\n For increased accuracy, the number for which the tangent should be evaluated\n can be supplied as a double-double number (i.e., a non-evaluated sum of two\n double-precision floating-point numbers `x` and `y`).\n\n The numbers `x` and `y` must satisfy `|y| < 0.5 * ulp( x )`.\n\n If either `x` or `y` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value (in radians).\n\n y: number\n Tail of `x`.\n\n k: integer\n If `k=1`, the function returns `tan(x+y)`. If `k=-1`, the function\n returns the negative inverse `-1/tan(x+y)`.\n\n Returns\n -------\n out: number\n Tangent.\n\n Examples\n --------\n > var out = base.kernelTan( PI/4.0, 0.0, 1 )\n ~1.0\n > out = base.kernelTan( PI/4.0, 0.0, -1 )\n ~-1.0\n > out = base.kernelTan( PI/6.0, 0.0, 1 )\n ~0.577\n > out = base.kernelTan( 0.664, 5.288e-17, 1 )\n ~0.783\n\n > out = base.kernelTan( NaN, 0.0, 1 )\n NaN\n > out = base.kernelTan( 3.0, NaN, 1 )\n NaN\n > out = base.kernelTan( 3.0, 0.0, NaN )\n NaN\n\n See Also\n --------\n base.kernelCos, base.kernelSin, base.tan\n"
+base.kroneckerDelta,"\nbase.kroneckerDelta( i, j )\n Evaluates the Kronecker delta.\n\n If `i == j`, the function returns `1`; otherwise, the function returns zero.\n\n Parameters\n ----------\n i: number\n Input value.\n\n j: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.kroneckerDelta( 3.14, 0.0 )\n 0.0\n > y = base.kroneckerDelta( 3.14, 3.14 )\n 1.0\n\n See Also\n --------\n base.diracDelta\n"
+base.lcm,"\nbase.lcm( a, b )\n Computes the least common multiple (lcm).\n\n If either `a` or `b` is `0`, the function returns `0`.\n\n Both `a` and `b` must have integer values; otherwise, the function returns\n `NaN`.\n\n Parameters\n ----------\n a: integer\n First integer.\n\n b: integer\n Second integer.\n\n Returns\n -------\n out: integer\n Least common multiple.\n\n Examples\n --------\n > var v = base.lcm( 21, 6 )\n 42\n\n See Also\n --------\n base.gcd\n"
+base.ldexp,"\nbase.ldexp( frac, exp )\n Multiplies a double-precision floating-point number by an integer power of\n two; i.e., `x = frac * 2^exp`.\n\n If `frac` equals positive or negative `zero`, `NaN`, or positive or negative\n infinity, the function returns a value equal to `frac`.\n\n Parameters\n ----------\n frac: number\n Fraction.\n\n exp: number\n Exponent.\n\n Returns\n -------\n out: number\n Double-precision floating-point number equal to `frac * 2^exp`.\n\n Examples\n --------\n > var x = base.ldexp( 0.5, 3 )\n 4.0\n > x = base.ldexp( 4.0, -2 )\n 1.0\n > x = base.ldexp( 0.0, 20 )\n 0.0\n > x = base.ldexp( -0.0, 39 )\n -0.0\n > x = base.ldexp( NaN, -101 )\n NaN\n > x = base.ldexp( PINF, 11 )\n Infinity\n > x = base.ldexp( NINF, -118 )\n -Infinity\n\n See Also\n --------\n base.frexp\n"
+base.ln,"\nbase.ln( x )\n Evaluates the natural logarithm.\n\n For negative numbers, the natural logarithm is not defined.\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.ln( 4.0 )\n ~1.386\n > y = base.ln( 0.0 )\n -Infinity\n > y = base.ln( PINF )\n Infinity\n > y = base.ln( NaN )\n NaN\n > y = base.ln( -4.0 )\n NaN\n\n See Also\n --------\n base.exp, base.log10, base.log1p, base.log2\n"
+base.log,"\nbase.log( x, b )\n Computes the base `b` logarithm of `x`.\n\n For negative `b` or `x`, the function returns `NaN`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n b: number\n Base.\n\n Returns\n -------\n y: number\n Logarithm (base `b`).\n\n Examples\n --------\n > var y = base.log( 100.0, 10.0 )\n 2.0\n > y = base.log( 16.0, 2.0 )\n 4.0\n > y = base.log( 5.0, 1.0 )\n Infinity\n > y = base.log( NaN, 2.0 )\n NaN\n > y = base.log( 1.0, NaN )\n NaN\n > y = base.log( -4.0, 2.0 )\n NaN\n > y = base.log( 4.0, -2.0 )\n NaN\n\n See Also\n --------\n base.exp, base.ln, base.log10, base.log1p, base.log2\n"
+base.log1mexp,"\nbase.log1mexp( x )\n Evaluates the natural logarithm of `1-exp(-|x|)`.\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.log1mexp( -10.0 )\n ~-0.00005\n > y = base.log1mexp( 0.0 )\n -Infinity\n > y = base.log1mexp( 5.0 )\n ~-0.00676\n > y = base.log1mexp( 10.0 )\n ~-0.00005\n > y = base.log1mexp( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.ln, base.log1p, base.log1pexp"
+base.log1p,"\nbase.log1p( x )\n Evaluates the natural logarithm of `1+x`.\n\n For `x < -1`, the function returns `NaN`, as the natural logarithm is not\n defined for negative numbers.\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.log1p( 4.0 )\n ~1.609\n > y = base.log1p( -1.0 )\n -Infinity\n > y = base.log1p( 0.0 )\n 0.0\n > y = base.log1p( -0.0 )\n -0.0\n > y = base.log1p( -2.0 )\n NaN\n > y = base.log1p( NaN )\n NaN\n\n See Also\n --------\n base.ln, base.log\n"
+base.log1pexp,"\nbase.log1pexp( x )\n Evaluates the natural logarithm of `1+exp(x)`.\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.log1pexp( -10.0 )\n ~0.000045\n > y = base.log1pexp( 0.0 )\n ~0.693147\n > y = base.log1pexp( 5.0 )\n ~5.006715\n > y = base.log1pexp( 34.0 )\n 34.0\n > y = base.log1pexp( NaN )\n NaN\n\n See Also\n --------\n base.exp, base.ln, base.log1mexp, base.log1p"
+base.log2,"\nbase.log2( x )\n Evaluates the binary logarithm (base two).\n\n For negative numbers, the binary logarithm is not defined.\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.log2( 4.0 )\n 2.0\n > y = base.log2( 8.0 )\n 3.0\n > y = base.log2( 0.0 )\n -Infinity\n > y = base.log2( PINF )\n Infinity\n > y = base.log2( NaN )\n NaN\n > y = base.log2( -4.0 )\n NaN\n\n See Also\n --------\n base.exp2, base.ln, base.log\n"
+base.log10,"\nbase.log10( x )\n Evaluates the common logarithm (base 10).\n\n For negative numbers, the common logarithm is not defined.\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.log10( 100.0 )\n 2.0\n > y = base.log10( 8.0 )\n ~0.903\n > y = base.log10( 0.0 )\n -Infinity\n > y = base.log10( PINF )\n Infinity\n > y = base.log10( NaN )\n NaN\n > y = base.log10( -4.0 )\n NaN\n\n See Also\n --------\n base.exp10, base.ln, base.log\n"
+base.logaddexp,"\nbase.logaddexp( x, y )\n Computes the natural logarithm of `exp(x) + exp(y)`.\n\n Parameters\n ----------\n x: number\n Input value.\n\n y: number\n Input value.\n\n Returns\n -------\n v: number\n Function value.\n\n Examples\n --------\n > var v = base.logaddexp( 90.0, 90.0 )\n ~90.6931\n > v = base.logaddexp( -20.0, 90.0 )\n 90.0\n > v = base.logaddexp( 0.0, -100.0 )\n ~3.7201e-44\n > v = base.logaddexp( NaN, NaN )\n NaN\n\n See Also\n --------\n base.exp, base.ln\n"
+base.logit,"\nbase.logit( p )\n Evaluates the logit function.\n\n Let `p` be the probability of some event. The logit function is defined as\n the logarithm of the odds `p / (1-p)`.\n\n If `p < 0` or `p > 1`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.logit( 0.2 )\n ~-1.386\n > y = base.logit( 0.9 )\n ~2.197\n > y = base.logit( -4.0 )\n NaN\n > y = base.logit( 1.5 )\n NaN\n > y = base.logit( NaN )\n NaN\n\n"
+base.lucas,"\nbase.lucas( n )\n Computes the nth Lucas number.\n\n Lucas numbers follow the recurrence relation\n\n L_n = L_{n-1} + L_{n-2}\n\n with seed values L_0 = 2 and L_1 = 1.\n\n If `n` is greater than `76`, the function returns `NaN`, as larger Lucas\n numbers cannot be accurately represented due to limitations of double-\n precision floating-point format.\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: integer\n Lucas number.\n\n Examples\n --------\n > var y = base.lucas( 0 )\n 2\n > y = base.lucas( 1 )\n 1\n > y = base.lucas( 2 )\n 3\n > y = base.lucas( 3 )\n 4\n > y = base.lucas( 4 )\n 7\n > y = base.lucas( 77 )\n NaN\n > y = base.lucas( NaN )\n NaN\n\n See Also\n --------\n base.fibonacci, base.negalucas\n"
+base.lucaspoly,"\nbase.lucaspoly( n, x )\n Evaluates a Lucas polynomial.\n\n Parameters\n ----------\n n: integer\n Lucas polynomial to evaluate.\n\n x: number\n Value at which to evaluate the Lucas polynomial.\n\n Returns\n -------\n out: number\n Evaluated Lucas polynomial.\n\n Examples\n --------\n // 2^5 + 5*2^3 + 5*2\n > var v = base.lucaspoly( 5, 2.0 )\n 82.0\n\n\nbase.lucaspoly.factory( n )\n Returns a function for evaluating a Lucas polynomial.\n\n Parameters\n ----------\n n: integer\n Lucas polynomial to evaluate.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a Lucas polynomial.\n\n Examples\n --------\n > var polyval = base.lucaspoly.factory( 5 );\n\n // 1^5 + 5*1^2 + 5\n > var v = polyval( 1.0 )\n 11.0\n\n // 2^5 + 5*2^3 + 5*2\n > v = polyval( 2.0 )\n 82.0\n\n See Also\n --------\n base.evalpoly, base.fibpoly\n"
+base.max,"\nbase.max( [x[, y[, ...args]]] )\n Returns the maximum value.\n\n If any argument is `NaN`, the function returns `NaN`.\n\n When an empty set is considered a subset of the extended reals (all real\n numbers, including positive and negative infinity), negative infinity is the\n least upper bound. Similar to zero being the identity element for the sum of\n an empty set and to one being the identity element for the product of an\n empty set, negative infinity is the identity element for the maximum, and\n thus, if not provided any arguments, the function returns negative infinity.\n\n Parameters\n ----------\n x: number (optional)\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: number\n Maximum value.\n\n Examples\n --------\n > var v = base.max( 3.14, 4.2 )\n 4.2\n > v = base.max( 5.9, 3.14, 4.2 )\n 5.9\n > v = base.max( 3.14, NaN )\n NaN\n > v = base.max( +0.0, -0.0 )\n +0.0\n\n See Also\n --------\n base.maxabs, base.min\n"
+base.maxabs,"\nbase.maxabs( [x[, y[, ...args]]] )\n Returns the maximum absolute value.\n\n If any argument is `NaN`, the function returns `NaN`.\n\n When an empty set is considered a subset of the extended reals (all real\n numbers, including positive and negative infinity), negative infinity is the\n least upper bound. Similar to zero being the identity element for the sum of\n an empty set and to one being the identity element for the product of an\n empty set, negative infinity is the identity element for the maximum, and\n thus, if not provided any arguments, the function returns `+infinity` (i.e.,\n the absolute value of `-infinity`).\n\n Parameters\n ----------\n x: number (optional)\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: number\n Maximum absolute value.\n\n Examples\n --------\n > var v = base.maxabs( 3.14, -4.2 )\n 4.2\n > v = base.maxabs( 5.9, 3.14, 4.2 )\n 5.9\n > v = base.maxabs( 3.14, NaN )\n NaN\n > v = base.maxabs( +0.0, -0.0 )\n +0.0\n\n See Also\n --------\n base.max, base.minabs\n"
+base.min,"\nbase.min( [x[, y[, ...args]]] )\n Returns the minimum value.\n\n If any argument is `NaN`, the function returns `NaN`.\n\n When an empty set is considered a subset of the extended reals (all real\n numbers, including positive and negative infinity), positive infinity is the\n greatest lower bound. Similar to zero being the identity element for the sum\n of an empty set and to one being the identity element for the product of an\n empty set, positive infinity is the identity element for the minimum, and\n thus, if not provided any arguments, the function returns positive infinity.\n\n Parameters\n ----------\n x: number (optional)\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: number\n Minimum value.\n\n Examples\n --------\n > var v = base.min( 3.14, 4.2 )\n 3.14\n > v = base.min( 5.9, 3.14, 4.2 )\n 3.14\n > v = base.min( 3.14, NaN )\n NaN\n > v = base.min( +0.0, -0.0 )\n -0.0\n\n See Also\n --------\n base.max, base.minabs\n"
+base.minabs,"\nbase.minabs( [x[, y[, ...args]]] )\n Returns the minimum absolute value.\n\n If any argument is `NaN`, the function returns `NaN`.\n\n When an empty set is considered a subset of the extended reals (all real\n numbers, including positive and negative infinity), positive infinity is the\n greatest upper bound. Similar to zero being the identity element for the sum\n of an empty set and to one being the identity element for the product of an\n empty set, positive infinity is the identity element for the minimum, and\n thus, if not provided any arguments, the function returns positive infinity.\n\n Parameters\n ----------\n x: number (optional)\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: number\n Minimum absolute value.\n\n Examples\n --------\n > var v = base.minabs( 3.14, -4.2 )\n 3.14\n > v = base.minabs( 5.9, 3.14, 4.2 )\n 3.14\n > v = base.minabs( 3.14, NaN )\n NaN\n > v = base.minabs( +0.0, -0.0 )\n +0.0\n\n See Also\n --------\n base.maxabs, base.min\n"
+base.minmax,"\nbase.minmax( [out,] x[, y[, ...args]] )\n Returns the minimum and maximum values.\n\n If any argument is `NaN`, the function returns `NaN` for both the minimum\n and maximum values.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output object.\n\n x: number\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Minimum and maximum values.\n\n Examples\n --------\n > var v = base.minmax( 3.14, 4.2 )\n [ 3.14, 4.2 ]\n > v = base.minmax( 5.9, 3.14, 4.2 )\n [ 3.14, 5.9 ]\n > v = base.minmax( 3.14, NaN )\n [ NaN, NaN ]\n > v = base.minmax( +0.0, -0.0 )\n [ -0.0, +0.0 ]\n > v = base.minmax( 3.14 )\n [ 3.14, 3.14 ]\n > var out = new Array( 2 );\n > v = base.minmax( out, 3.14 )\n [ 3.14, 3.14 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.max, base.min, base.minmaxabs\n"
+base.minmaxabs,"\nbase.minmaxabs( [out,] x[, y[, ...args]] )\n Returns the minimum and maximum absolute values.\n\n If any argument is `NaN`, the function returns `NaN` for both the minimum\n and maximum absolute values.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output object.\n\n x: number\n First number.\n\n y: number (optional)\n Second number.\n\n args: ...number (optional)\n Numbers.\n\n Returns\n -------\n out: Array|TypedArray|Object\n Minimum and maximum absolute values.\n\n Examples\n --------\n > var v = base.minmaxabs( 3.14, 4.2 )\n [ 3.14, 4.2 ]\n > v = base.minmaxabs( -5.9, 3.14, 4.2 )\n [ 3.14, 5.9 ]\n > v = base.minmaxabs( 3.14, NaN )\n [ NaN, NaN ]\n > v = base.minmaxabs( +0.0, -0.0 )\n [ 0.0, 0.0 ]\n > v = base.minmaxabs( 3.14 )\n [ 3.14, 3.14 ]\n > var out = new Array( 2 );\n > v = base.minmaxabs( out, 3.14 )\n [ 3.14, 3.14 ]\n > var bool = ( v === out )\n true\n\n See Also\n --------\n base.maxabs, base.minabs, base.minmax\n"
+base.modf,"\nbase.modf( [out,] x )\n Decomposes a double-precision floating-point number into integral and\n fractional parts, each having the same type and sign as the input value.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n x: number\n Input value.\n\n Returns\n -------\n parts: Array|TypedArray|Object\n Integral and fractional parts.\n\n Examples\n --------\n > var parts = base.modf( 3.14 )\n [ 3.0, 0.14000000000000012 ]\n > parts = base.modf( 3.14 )\n [ 3.0, 0.14000000000000012 ]\n > parts = base.modf( +0.0 )\n [ +0.0, +0.0 ]\n > parts = base.modf( -0.0 )\n [ -0.0, -0.0 ]\n > parts = base.modf( PINF )\n [ Infinity, +0.0 ]\n > parts = base.modf( NINF )\n [ -Infinity, -0.0 ]\n > parts = base.modf( NaN )\n [ NaN, NaN ]\n\n // Provide an output array:\n > var out = new Float64Array( 2 );\n > parts = base.modf( out, 3.14 )\n [ 3.0, 0.14000000000000012 ]\n > var bool = ( parts === out )\n true\n\n"
+base.ndarray,"\nbase.ndarray( dtype, ndims[, options] )\n Returns an ndarray constructor.\n\n Parameters\n ----------\n dtype: string\n Underlying data type.\n\n ndims: integer\n Number of dimensions.\n\n options: Object (optional)\n Options.\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 Returns\n -------\n ctor: Function\n ndarray constructor.\n\n ctor.BYTES_PER_ELEMENT: integer\n Size (in bytes) of each array element (if known).\n\n ctor.dtype: string\n Underlying data type.\n\n ctor.ndims: integer\n Number of dimensions.\n\n ctor.prototype.byteLength: integer\n Size (in bytes) of the array (if known).\n\n ctor.prototype.BYTES_PER_ELEMENT: integer\n Size (in bytes) of each array element (if known).\n\n ctor.prototype.data: ArrayLikeObject|TypedArray|Buffer\n Pointer to the underlying data buffer.\n\n ctor.prototype.dtype: string\n Underlying data type.\n\n ctor.prototype.flags: Object\n Information about the memory layout of the array.\n\n ctor.prototype.length: integer\n Length of the array (i.e., number of elements).\n\n ctor.prototype.ndims: integer\n Number of dimensions.\n\n ctor.prototype.offset: integer\n Index offset which specifies the buffer index at which to start\n iterating over array elements.\n\n ctor.prototype.order: string\n Array order. The array order is either row-major (C-style) or column-\n major (Fortran-style).\n\n ctor.prototype.shape: Array\n Array shape.\n\n ctor.prototype.strides: Array\n Index strides which specify how to access data along corresponding array\n dimensions.\n\n ctor.prototype.get: Function\n Returns an array element specified according to provided subscripts. The\n number of provided subscripts should equal the number of dimensions.\n\n ctor.prototype.iget: Function\n Returns an array element located at a specified linear index.\n\n ctor.prototype.set: Function\n Sets an array element specified according to provided subscripts. The\n number of provided subscripts should equal the number of dimensions.\n\n ctor.prototype.iset: Function\n Sets an array element located at a specified linear index.\n\n ctor.prototype.toString: Function\n Serializes an ndarray as a string. This method does **not** serialize\n data outside of the buffer region defined by the array configuration.\n\n ctor.prototype.toJSON: Function\n Serializes an ndarray as a JSON object. This method does **not**\n serialize data outside of the buffer region defined by the array\n configuration.\n\n Examples\n --------\n > var ctor = base.ndarray( 'float64', 3 )\n \n\n // To create a new instance...\n > var b = [ 1, 2, 3, 4 ]; // underlying data buffer\n > var d = [ 2, 2 ]; // shape\n > var s = [ 2, 1 ]; // strides\n > var o = 0; // index offset\n > var arr = ctor( b, d, s, o, 'row-major' )\n \n\n // Get an element using subscripts:\n > var v = arr.get( 1, 1 )\n 4\n\n // Get an element using a linear index:\n > v = arr.iget( 3 )\n 4\n\n // Set an element using subscripts:\n > arr.set( 1, 1, 40 );\n > arr.get( 1, 1 )\n 40\n\n // Set an element using a linear index:\n > arr.iset( 3, 99 );\n > arr.get( 1, 1 )\n 99\n\n See Also\n --------\n array, ndarray\n"
+base.ndarrayMemoized,"\nbase.ndarrayMemoized( dtype, ndims[, options] )\n Returns a memoized ndarray constructor.\n\n Parameters\n ----------\n dtype: string\n Underlying data type.\n\n ndims: integer\n Number of dimensions.\n\n options: Object (optional)\n Options.\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 Returns\n -------\n ctor: Function\n Memoized ndarray constructor.\n\n ctor.BYTES_PER_ELEMENT: integer\n Size (in bytes) of each array element (if known).\n\n ctor.dtype: string\n Underlying data type.\n\n ctor.ndims: integer\n Number of dimensions.\n\n ctor.prototype.byteLength: integer\n Size (in bytes) of the array (if known).\n\n ctor.prototype.BYTES_PER_ELEMENT: integer\n Size (in bytes) of each array element (if known).\n\n ctor.prototype.data: ArrayLikeObject|TypedArray|Buffer\n Pointer to the underlying data buffer.\n\n ctor.prototype.dtype: string\n Underlying data type.\n\n ctor.prototype.flags: Object\n Information about the memory layout of the array.\n\n ctor.prototype.length: integer\n Length of the array (i.e., number of elements).\n\n ctor.prototype.ndims: integer\n Number of dimensions.\n\n ctor.prototype.offset: integer\n Index offset which specifies the buffer index at which to start\n iterating over array elements.\n\n ctor.prototype.order: string\n Array order. The array order is either row-major (C-style) or column-\n major (Fortran-style).\n\n ctor.prototype.shape: Array\n Array shape.\n\n ctor.prototype.strides: Array\n Index strides which specify how to access data along corresponding array\n dimensions.\n\n ctor.prototype.get: Function\n Returns an array element specified according to provided subscripts. The\n number of provided subscripts should equal the number of dimensions.\n\n ctor.prototype.iget: Function\n Returns an array element located at a specified linear index.\n\n ctor.prototype.set: Function\n Sets an array element specified according to provided subscripts. The\n number of provided subscripts should equal the number of dimensions.\n\n ctor.prototype.iset: Function\n Sets an array element located at a specified linear index.\n\n ctor.prototype.toString: Function\n Serializes an ndarray as a string. This method does **not** serialize\n data outside of the buffer region defined by the array configuration.\n\n ctor.prototype.toJSON: Function\n Serializes an ndarray as a JSON object. This method does **not**\n serialize data outside of the buffer region defined by the array\n configuration.\n\n Examples\n --------\n > var ctor = base.ndarrayMemoized( 'float64', 3 )\n \n > var f = base.ndarrayMemoized( 'float64', 3 )\n \n > var bool = ( f === ctor )\n true\n\n // To create a new instance...\n > var b = [ 1, 2, 3, 4 ]; // underlying data buffer\n > var d = [ 2, 2 ]; // shape\n > var s = [ 2, 1 ]; // strides\n > var o = 0; // index offset\n > var arr = ctor( b, d, s, o, 'row-major' )\n \n\n // Get an element using subscripts:\n > var v = arr.get( 1, 1 )\n 4\n\n // Get an element using a linear index:\n > v = arr.iget( 3 )\n 4\n\n // Set an element using subscripts:\n > arr.set( 1, 1, 40 );\n > arr.get( 1, 1 )\n 40\n\n // Set an element using a linear index:\n > arr.iset( 3, 99 );\n > arr.get( 1, 1 )\n 99\n\n See Also\n --------\n array, base.ndarray, ndarray, ndarrayMemoized\n"
+base.negafibonacci,"\nbase.negafibonacci( n )\n Computes the nth negaFibonacci number.\n\n The negaFibonacci numbers follow the recurrence relation\n\n F_{n-2} = F_{n} - F_{n-1}\n\n with seed values F_0 = 0 and F_{-1} = 1.\n\n If `|n|` is greater than `78`, the function returns `NaN` as larger\n negaFibonacci numbers cannot be accurately represented due to limitations of\n double-precision floating-point format.\n\n If not provided a non-positive 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: integer\n NegaFibonacci number.\n\n Examples\n --------\n > var y = base.negafibonacci( 0 )\n 0\n > y = base.negafibonacci( -1 )\n 1\n > y = base.negafibonacci( -2 )\n -1\n > y = base.negafibonacci( -3 )\n 2\n > y = base.negafibonacci( -4 )\n -3\n > y = base.negafibonacci( -79 )\n NaN\n > y = base.negafibonacci( -80 )\n NaN\n > y = base.negafibonacci( NaN )\n NaN\n\n See Also\n --------\n base.fibonacci, base.negalucas\n"
+base.negalucas,"\nbase.negalucas( n )\n Computes the nth negaLucas number.\n\n The negaLucas numbers follow the recurrence relation\n\n L_{n-2} = L_{n} - L_{n-1}\n\n with seed values L_0 = 2 and L_{-1} = -1.\n\n If `|n|` is greater than `76`, the function returns `NaN` as larger\n negaLucas numbers cannot be accurately represented due to limitations of\n double-precision floating-point format.\n\n If not provided a non-positive 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: integer\n NegaLucas number.\n\n Examples\n --------\n > var y = base.negalucas( 0 )\n 2\n > y = base.negalucas( -1 )\n -1\n > y = base.negalucas( -2 )\n 3\n > y = base.negalucas( -3 )\n -4\n > y = base.negalucas( -4 )\n 7\n > y = base.negalucas( -77 )\n NaN\n > y = base.negalucas( -78 )\n NaN\n > y = base.negalucas( NaN )\n NaN\n\n See Also\n --------\n base.fibonacci, base.lucas, base.negafibonacci\n"
+base.nonfibonacci,"\nbase.nonfibonacci( n )\n Computes the nth non-Fibonacci 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 Non-Fibonacci number.\n\n Examples\n --------\n > var v = base.nonfibonacci( 1 )\n 4\n > v = base.nonfibonacci( 2 )\n 6\n > v = base.nonfibonacci( 3 )\n 7\n > v = base.nonfibonacci( NaN )\n NaN\n\n See Also\n --------\n base.fibonacci\n"
+base.normalize,"\nbase.normalize( [out,] x )\n Returns a normal number and exponent satisfying `x = y * 2^exp` as an array.\n\n The first element of the returned array corresponds to `y` and the second to\n `exp`.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n x: number\n Double-precision floating-point number.\n\n Returns\n -------\n out: Array|TypedArray|Object\n An array containing `y` and `exp`.\n\n Examples\n --------\n > var out = base.normalize( 3.14e-319 )\n [ 1.4141234400356668e-303, -52 ]\n > var y = out[ 0 ];\n > var exponent = out[ 1 ];\n > var bool = ( y*base.pow(2.0, exponent) === 3.14e-319 )\n true\n\n // Special cases:\n > out = base.normalize( 0.0 )\n [ 0.0, 0 ];\n > out = base.normalize( PINF )\n [ Infinity, 0 ]\n > out = base.normalize( NINF )\n [ -Infinity, 0 ]\n > out = base.normalize( NaN )\n [ NaN, 0 ]\n\n // Provide an output array:\n > out = new Float64Array( 2 );\n > var v = base.normalize( out, 3.14e-319 )\n [ 1.4141234400356668e-303, -52 ]\n > bool = ( v === out )\n true\n\n See Also\n --------\n base.normalizef\n"
+base.normalizef,"\nbase.normalizef( [out,] x )\n Returns a normal number `y` and exponent `exp` satisfying `x = y * 2^exp` as\n an array.\n\n The first element of the returned array corresponds to `y` and the second to\n `exp`.\n\n While the function accepts higher precision floating-point numbers, beware\n that providing such numbers can be a source of subtle bugs as the relation\n `x = y * 2^exp` may not hold.\n\n Parameters\n ----------\n out: Array|TypedArray|Object (optional)\n Output array.\n\n x: float\n Single-precision floating-point number.\n\n Returns\n -------\n out: Array|TypedArray|Object\n An array containing `y` and `exp`.\n\n Examples\n --------\n > var out = base.normalizef( base.float64ToFloat32( 1.401e-45 ) )\n [ 1.1754943508222875e-38, -23 ]\n > var y = out[ 0 ];\n > var exp = out[ 1 ];\n > var bool = ( y*base.pow(2,exp) === base.float64ToFloat32(1.401e-45) )\n true\n\n // Special cases:\n > out = base.normalizef( FLOAT32_PINF )\n [ Infinity, 0 ]\n > out = base.normalizef( FLOAT32_NINF )\n [ -Infinity, 0 ]\n > out = base.normalizef( NaN )\n [ NaN, 0 ]\n\n // Provide an output array:\n > out = new Float32Array( 2 );\n > var v = base.normalizef( out, base.float64ToFloat32( 1.401e-45 ) )\n [ 1.1754943508222875e-38, -23.0 ]\n > bool = ( v === out )\n true\n\n See Also\n --------\n base.normalize\n"
+base.normhermitepoly,"\nbase.normhermitepoly( n, x )\n Evaluates a normalized Hermite polynomial.\n\n Parameters\n ----------\n n: integer\n Nonnegative polynomial degree.\n\n x: number\n Value at which to evaluate the polynomial.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.normhermitepoly( 1, 0.5 )\n 0.5\n > y = base.normhermitepoly( -1, 0.5 )\n NaN\n > y = base.normhermitepoly( 0, 0.5 )\n 1.0\n > y = base.normhermitepoly( 2, 0.5 )\n -0.75\n\n\nbase.normhermitepoly.factory( n )\n Returns a function for evaluating a normalized Hermite polynomial.\n\n Parameters\n ----------\n n: integer\n Nonnegative polynomial degree.\n\n Returns\n -------\n fcn: Function\n Function for evaluating a normalized Hermite polynomial.\n\n Examples\n --------\n > var polyval = base.normhermitepoly.factory( 2 );\n > var v = polyval( 0.5 )\n -0.75\n\n See Also\n --------\n base.evalpoly, base.hermitepoly\n"
+base.pdiff,"\nbase.pdiff( x, y )\n Returns the positive difference between `x` and `y` if `x > y`; otherwise,\n returns `0`.\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 Positive difference.\n\n Examples\n --------\n > var v = base.pdiff( 5.9, 3.14 )\n 2.76\n > v = base.pdiff( 3.14, 4.2 )\n 0.0\n > v = base.pdiff( 3.14, NaN )\n NaN\n > v = base.pdiff( -0.0, +0.0 )\n +0.0\n\n"
+base.polygamma,"\nbase.polygamma( n, x )\n Evaluates the polygamma function of order `n`; i.e., the (n+1)th derivative\n of the natural logarithm of the gamma function.\n\n If `n` is not a nonnegative integer, the function returns `NaN`.\n\n If `x` is zero or a negative integer, the function returns `NaN`.\n\n If provided `NaN` as either parameter, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Derivative order.\n\n x: number\n Input value.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var v = base.polygamma( 3, 1.2 )\n ~3.245\n > v = base.polygamma( 5, 1.2 )\n ~41.39\n > v = base.polygamma( 3, -4.9 )\n ~60014.239\n > v = base.polygamma( -1, 5.3 )\n NaN\n > v = base.polygamma( 2, -1.0 )\n Infinity\n\n See Also\n --------\n base.trigamma, base.digamma, base.gamma\n"
+base.pow,"\nbase.pow( b, x )\n Evaluates the exponential function `bˣ`.\n\n Parameters\n ----------\n b: number\n Base.\n\n x: number\n Exponent.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.pow( 2.0, 3.0 )\n 8.0\n > y = base.pow( 4.0, 0.5 )\n 2.0\n > y = base.pow( 100.0, 0.0 )\n 1.0\n > y = base.pow( PI, 5.0 )\n ~306.0197\n > y = base.pow( PI, -0.2 )\n ~0.7954\n > y = base.pow( NaN, 3.0 )\n NaN\n > y = base.pow( 5.0, NaN )\n NaN\n > y = base.pow( NaN, NaN )\n NaN\n\n See Also\n --------\n base.exp, base.powm1\n"
+base.powm1,"\nbase.powm1( b, x )\n Evaluates `bˣ - 1`.\n\n When `b` is close to `1` and/or `x` is small, this function is more accurate\n than naively computing `bˣ` and subtracting `1`.\n\n Parameters\n ----------\n b: number\n Base.\n\n x: number\n Exponent.\n\n Returns\n -------\n y: number\n Function value.\n\n Examples\n --------\n > var y = base.powm1( 2.0, 3.0 )\n 7.0\n > y = base.powm1( 4.0, 0.5 )\n 1.0\n > y = base.powm1( 0.0, 100.0 )\n -1.0\n > y = base.powm1( 100.0, 0.0 )\n 0.0\n > y = base.powm1( 0.0, 0.0 )\n 0.0\n > y = base.powm1( PI, 5.0 )\n ~305.0197\n > y = base.powm1( NaN, 3.0 )\n NaN\n > y = base.powm1( 5.0, NaN )\n NaN\n\n See Also\n --------\n base.pow\n"
+base.rad2deg,"\nbase.rad2deg( x )\n Converts an angle from radians to degrees.\n\n Parameters\n ----------\n x: number\n Angle in radians.\n\n Returns\n -------\n d: number\n Angle in degrees.\n\n Examples\n --------\n > var d = base.rad2deg( PI/2.0 )\n 90.0\n > d = base.rad2deg( -PI/4.0 )\n -45.0\n > d = base.rad2deg( NaN )\n NaN\n\n // Due to finite precision, canonical values may not be returned:\n > d = base.rad2deg( PI/6.0 )\n 29.999999999999996\n\n See Also\n --------\n base.deg2rad\n"
+base.ramp,"\nbase.ramp( x )\n Evaluates the ramp function.\n\n If `x >= 0`, the function returns `x`; otherwise, the function returns 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.ramp( 3.14 )\n 3.14\n > y = base.ramp( -3.14 )\n 0.0\n\n See Also\n --------\n base.heaviside\n"
+base.random.arcsine,"\nbase.random.arcsine( a, b )\n Returns a pseudorandom number drawn from an arcsine distribution.\n\n If `a >= b`, the function returns `NaN`.\n\n If `a` or `b` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n a: number\n Minimum support.\n\n b: number\n Maximum support.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.arcsine( 2.0, 5.0 )\n \n\n\nbase.random.arcsine.factory( [a, b, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from an arcsine distribution.\n\n If provided `a` and `b`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `a` and `b`, the returned PRNG requires that both `a` and\n `b` be provided at each invocation.\n\n Parameters\n ----------\n a: number (optional)\n Minimum support.\n\n b: number (optional)\n Maximum support.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.arcsine.factory();\n > var r = rand( 0.0, 1.0 )\n \n > r = rand( -2.0, 2.0 )\n \n\n // Provide `a` and `b`:\n > rand = base.random.arcsine.factory( 0.0, 1.0 );\n > r = rand()\n \n > r = rand()\n \n\n\nbase.random.arcsine.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.arcsine.NAME\n 'arcsine'\n\n\nbase.random.arcsine.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.arcsine.PRNG;\n\n\nbase.random.arcsine.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.arcsine.seed;\n\n\nbase.random.arcsine.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.arcsine.seedLength;\n\n\nbase.random.arcsine.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.arcsine( 2.0, 4.0 )\n \n > r = base.random.arcsine( 2.0, 4.0 )\n \n > r = base.random.arcsine( 2.0, 4.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.arcsine.state\n \n\n > r = base.random.arcsine( 2.0, 4.0 )\n \n > r = base.random.arcsine( 2.0, 4.0 )\n \n\n // Set the state:\n > base.random.arcsine.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.arcsine( 2.0, 4.0 )\n \n > r = base.random.arcsine( 2.0, 4.0 )\n \n\n\nbase.random.arcsine.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.arcsine.stateLength;\n\n\nbase.random.arcsine.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.arcsine.byteLength;\n\n\nbase.random.arcsine.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.arcsine.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n See Also\n --------\n base.random.beta\n"
+base.random.bernoulli,"\nbase.random.bernoulli( p )\n Returns a pseudorandom number drawn from a Bernoulli distribution.\n\n If `p < 0` or `p > 1` or `p` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n r: integer\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.bernoulli( 0.8 );\n\n\nbase.random.bernoulli.factory( [p, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a Bernoulli distribution.\n\n If provided `p`, the returned PRNG returns random variates drawn from the\n specified distribution.\n\n If not provided `p`, the returned PRNG requires that `p` be provided at each\n invocation.\n\n Parameters\n ----------\n p: number (optional)\n Success probability.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.bernoulli.factory();\n > var r = rand( 0.3 );\n > r = rand( 0.59 );\n\n // Provide `p`:\n > rand = base.random.bernoulli.factory( 0.3 );\n > r = rand();\n > r = rand();\n\n\nbase.random.bernoulli.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.bernoulli.NAME\n 'bernoulli'\n\n\nbase.random.bernoulli.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.bernoulli.PRNG;\n\n\nbase.random.bernoulli.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.bernoulli.seed;\n\n\nbase.random.bernoulli.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.bernoulli.seedLength;\n\n\nbase.random.bernoulli.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.bernoulli( 0.3 )\n \n > r = base.random.bernoulli( 0.3 )\n \n > r = base.random.bernoulli( 0.3 )\n \n\n // Get a copy of the current state:\n > var state = base.random.bernoulli.state\n \n\n > r = base.random.bernoulli( 0.3 )\n \n > r = base.random.bernoulli( 0.3 )\n \n\n // Set the state:\n > base.random.bernoulli.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.bernoulli( 0.3 )\n \n > r = base.random.bernoulli( 0.3 )\n \n\n\nbase.random.bernoulli.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.bernoulli.stateLength;\n\n\nbase.random.bernoulli.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.bernoulli.byteLength;\n\n\nbase.random.bernoulli.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.bernoulli.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n See Also\n --------\n base.random.binomial\n"
+base.random.beta,"\nbase.random.beta( α, β )\n Returns a pseudorandom number drawn from a beta distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.beta( 2.0, 5.0 );\n\n\nbase.random.beta.factory( [α, β, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a beta distribution.\n\n If provided `α` and `β`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `α` and `β`, the returned PRNG requires that both `α` and\n `β` be provided at each invocation.\n\n Parameters\n ----------\n α: number (optional)\n First shape parameter.\n\n β: number (optional)\n Second shape parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.beta.factory();\n > var r = rand( 1.5, 1.5 );\n > r = rand( 2.0, 3.14 );\n\n // Provide `α` and `β`:\n > rand = base.random.beta.factory( 1.5, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.beta.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.beta.NAME\n 'beta'\n\n\nbase.random.beta.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.beta.PRNG;\n\n\nbase.random.beta.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.beta.seed;\n\n\nbase.random.beta.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.beta.seedLength;\n\n\nbase.random.beta.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.beta( 2.0, 5.0 )\n \n > r = base.random.beta( 2.0, 5.0 )\n \n > r = base.random.beta( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.beta.state\n \n\n > r = base.random.beta( 2.0, 5.0 )\n \n > r = base.random.beta( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.beta.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.beta( 2.0, 5.0 )\n \n > r = base.random.beta( 2.0, 5.0 )\n \n\n\nbase.random.beta.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.beta.stateLength;\n\n\nbase.random.beta.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.beta.byteLength;\n\n\nbase.random.beta.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.beta.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.betaprime,"\nbase.random.betaprime( α, β )\n Returns a pseudorandom number drawn from a beta prime distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n First shape parameter.\n\n β: number\n Second shape parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.betaprime( 2.0, 5.0 );\n\n\nbase.random.betaprime.factory( [α, β, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a beta prime distribution.\n\n If provided `α` and `β`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `α` and `β`, the returned PRNG requires that both `α` and\n `β` be provided at each invocation.\n\n Parameters\n ----------\n α: number (optional)\n First shape parameter.\n\n β: number (optional)\n Second shape parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.betaprime.factory();\n > var r = rand( 1.5, 1.5 );\n > r = rand( 2.0, 3.14 );\n\n // Provide `α` and `β`:\n > rand = base.random.betaprime.factory( 1.5, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.betaprime.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.betaprime.NAME\n 'betaprime'\n\n\nbase.random.betaprime.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.betaprime.PRNG;\n\n\nbase.random.betaprime.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.betaprime.seed;\n\n\nbase.random.betaprime.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.betaprime.seedLength;\n\n\nbase.random.betaprime.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.betaprime( 2.0, 5.0 )\n \n > r = base.random.betaprime( 2.0, 5.0 )\n \n > r = base.random.betaprime( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.betaprime.state\n \n\n > r = base.random.betaprime( 2.0, 5.0 )\n \n > r = base.random.betaprime( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.betaprime.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.betaprime( 2.0, 5.0 )\n \n > r = base.random.betaprime( 2.0, 5.0 )\n \n\n\nbase.random.betaprime.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.betaprime.stateLength;\n\n\nbase.random.betaprime.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.betaprime.byteLength;\n\n\nbase.random.betaprime.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.betaprime.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.binomial,"\nbase.random.binomial( n, p )\n Returns a pseudorandom number drawn from a binomial distribution.\n\n If `n` is not a positive integer or `p` is not a probability, the function\n returns `NaN`.\n\n If `n` or `p` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n n: integer\n Number of trials.\n\n p: number\n Success probability.\n\n Returns\n -------\n r: integer\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.binomial( 20, 0.8 );\n\n\nbase.random.binomial.factory( [n, p, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a binomial distribution.\n\n If provided `n` and `p`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `n` and `p`, the returned PRNG requires that both `n` and\n `p` be provided at each invocation.\n\n Parameters\n ----------\n n: integer (optional)\n Number of trials.\n\n p: number (optional)\n Success probability.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.binomial.factory();\n > var r = rand( 20, 0.3 );\n > r = rand( 10, 0.77 );\n\n // Provide `n` and `p`:\n > rand = base.random.binomial.factory( 10, 0.8 );\n > r = rand();\n > r = rand();\n\n\nbase.random.binomial.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.binomial.NAME\n 'binomial'\n\n\nbase.random.binomial.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.binomial.PRNG;\n\n\nbase.random.binomial.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.binomial.seed;\n\n\nbase.random.binomial.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.binomial.seedLength;\n\n\nbase.random.binomial.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.binomial( 20, 0.8 )\n \n > r = base.random.binomial( 20, 0.8 )\n \n > r = base.random.binomial( 20, 0.8 )\n \n\n // Get a copy of the current state:\n > var state = base.random.binomial.state\n \n\n > r = base.random.binomial( 20, 0.8 )\n \n > r = base.random.binomial( 20, 0.8 )\n \n\n // Set the state:\n > base.random.binomial.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.binomial( 20, 0.8 )\n \n > r = base.random.binomial( 20, 0.8 )\n \n\n\nbase.random.binomial.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.binomial.stateLength;\n\n\nbase.random.binomial.byteLength\n Size of generator state.\n\n Examples\n --------\n > var sz = base.random.binomial.byteLength;\n\n\nbase.random.binomial.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.binomial.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.boxMuller,"\nbase.random.boxMuller()\n Returns a pseudorandom number drawn from a standard normal distribution.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.boxMuller();\n\n\nbase.random.boxMuller.factory( [options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a standard normal distribution.\n\n Parameters\n ----------\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.boxMuller.factory();\n > r = rand();\n > r = rand();\n\n\nbase.random.boxMuller.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.boxMuller.NAME\n 'box-muller'\n\n\nbase.random.boxMuller.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.boxMuller.PRNG;\n\n\nbase.random.boxMuller.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.boxMuller.seed;\n\n\nbase.random.boxMuller.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.boxMuller.seedLength;\n\n\nbase.random.boxMuller.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.boxMuller()\n \n > r = base.random.boxMuller()\n \n > r = base.random.boxMuller()\n \n\n // Get a copy of the current state:\n > var state = base.random.boxMuller.state\n \n\n > r = base.random.boxMuller()\n \n > r = base.random.boxMuller()\n \n\n // Set the state:\n > base.random.boxMuller.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.boxMuller()\n \n > r = base.random.boxMuller()\n \n\n\nbase.random.boxMuller.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.boxMuller.stateLength;\n\n\nbase.random.boxMuller.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.boxMuller.byteLength;\n\n\nbase.random.boxMuller.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.boxMuller.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.cauchy,"\nbase.random.cauchy( x0, Ɣ )\n Returns a pseudorandom number drawn from a Cauchy distribution.\n\n If `x0` or `Ɣ` is `NaN` or `Ɣ <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n x0: number\n Location parameter.\n\n Ɣ: number\n Scale parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.cauchy( 2.0, 5.0 );\n\n\nbase.random.cauchy.factory( [x0, Ɣ, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a Cauchy distribution.\n\n If provided `x0` and `Ɣ`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `x0` and `Ɣ`, the returned PRNG requires that both `x0` and\n `Ɣ` be provided at each invocation.\n\n Parameters\n ----------\n x0: number (optional)\n Location parameter.\n\n Ɣ: number (optional)\n Scale parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.cauchy.factory();\n > var r = rand( 0.0, 1.5 );\n > r = rand( -2.0, 2.0 );\n\n // Provide `x0` and `Ɣ`:\n > rand = base.random.cauchy.factory( 0.0, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.cauchy.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.cauchy.NAME\n 'cauchy'\n\n\nbase.random.cauchy.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.cauchy.PRNG;\n\n\nbase.random.cauchy.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.cauchy.seed;\n\n\nbase.random.cauchy.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.cauchy.seedLength;\n\n\nbase.random.cauchy.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.cauchy( 2.0, 5.0 )\n \n > r = base.random.cauchy( 2.0, 5.0 )\n \n > r = base.random.cauchy( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.cauchy.state\n \n\n > r = base.random.cauchy( 2.0, 5.0 )\n \n > r = base.random.cauchy( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.cauchy.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.cauchy( 2.0, 5.0 )\n \n > r = base.random.cauchy( 2.0, 5.0 )\n \n\n\nbase.random.cauchy.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.cauchy.stateLength;\n\n\nbase.random.cauchy.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.cauchy.byteLength;\n\n\nbase.random.cauchy.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.cauchy.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.chi,"\nbase.random.chi( k )\n Returns a pseudorandom number drawn from a chi distribution.\n\n If `k <= 0` or `k` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.chi( 2 );\n\n\nbase.random.chi.factory( [k, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a chi distribution.\n\n If provided `k`, the returned PRNG returns random variates drawn from the\n specified distribution.\n\n If not provided `k`, the returned PRNG requires that `k` be provided at each\n invocation.\n\n Parameters\n ----------\n k: number (optional)\n Degrees of freedom.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.chi.factory();\n > var r = rand( 5 );\n > r = rand( 3.14 );\n\n // Provide `k`:\n > rand = base.random.chi.factory( 3 );\n > r = rand();\n > r = rand();\n\n\nbase.random.chi.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.chi.NAME\n 'chi'\n\n\nbase.random.chi.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.chi.PRNG;\n\n\nbase.random.chi.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.chi.seed;\n\n\nbase.random.chi.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.chi.seedLength;\n\n\nbase.random.chi.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.chi( 2 )\n \n > r = base.random.chi( 2 )\n \n > r = base.random.chi( 2 )\n \n\n // Get a copy of the current state:\n > var state = base.random.chi.state\n \n\n > r = base.random.chi( 2 )\n \n > r = base.random.chi( 2 )\n \n\n // Set the state:\n > base.random.chi.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.chi( 2 )\n \n > r = base.random.chi( 2 )\n \n\n\nbase.random.chi.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.chi.stateLength;\n\n\nbase.random.chi.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.chi.byteLength;\n\n\nbase.random.chi.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.chi.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.chisquare,"\nbase.random.chisquare( k )\n Returns a pseudorandom number drawn from a chi-square distribution.\n\n If `k <= 0` or `k` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: number\n Degrees of freedom.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.chisquare( 2 );\n\n\nbase.random.chisquare.factory( [k, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a chi-square distribution.\n\n If provided `k`, the returned PRNG returns random variates drawn from the\n specified distribution.\n\n If not provided `k`, the returned PRNG requires that `k` be provided at each\n invocation.\n\n Parameters\n ----------\n k: number (optional)\n Degrees of freedom.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.chisquare.factory();\n > var r = rand( 5 );\n > r = rand( 3.14 );\n\n // Provide `k`:\n > rand = base.random.chisquare.factory( 3 );\n > r = rand();\n > r = rand();\n\n\nbase.random.chisquare.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.chisquare.NAME\n 'chisquare'\n\n\nbase.random.chisquare.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.chisquare.PRNG;\n\n\nbase.random.chisquare.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.chisquare.seed;\n\n\nbase.random.chisquare.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.chisquare.seedLength;\n\n\nbase.random.chisquare.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.chisquare( 2 )\n \n > r = base.random.chisquare( 2 )\n \n > r = base.random.chisquare( 2 )\n \n\n // Get a copy of the current state:\n > var state = base.random.chisquare.state\n \n\n > r = base.random.chisquare( 2 )\n \n > r = base.random.chisquare( 2 )\n \n\n // Set the state:\n > base.random.chisquare.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.chisquare( 2 )\n \n > r = base.random.chisquare( 2 )\n \n\n\nbase.random.chisquare.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.chisquare.stateLength;\n\n\nbase.random.chisquare.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.chisquare.byteLength;\n\n\nbase.random.chisquare.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.chisquare.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.cosine,"\nbase.random.cosine( μ, s )\n Returns a pseudorandom number drawn from a raised cosine distribution.\n\n If `μ` or `s` is `NaN` or `s <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Location parameter.\n\n s: number\n Scale parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.cosine( 2.0, 5.0 );\n\n\nbase.random.cosine.factory( [μ, s, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a raised cosine distribution.\n\n If provided `μ` and `s`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `μ` and `s`, the returned PRNG requires that both `μ` and\n `s` be provided at each invocation.\n\n Parameters\n ----------\n μ: number (optional)\n Location parameter.\n\n s: number (optional)\n Scale parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.cosine.factory();\n > var r = rand( 0.1, 1.5 );\n > r = rand( 2.0, 3.14 );\n\n // Provide `μ` and `s`:\n > rand = base.random.cosine.factory( 0.1, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.cosine.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.cosine.NAME\n 'cosine'\n\n\nbase.random.cosine.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.cosine.PRNG;\n\n\nbase.random.cosine.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.cosine.seed;\n\n\nbase.random.cosine.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.cosine.seedLength;\n\n\nbase.random.cosine.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.cosine( 2.0, 5.0 )\n \n > r = base.random.cosine( 2.0, 5.0 )\n \n > r = base.random.cosine( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.cosine.state\n \n\n > r = base.random.cosine( 2.0, 5.0 )\n \n > r = base.random.cosine( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.cosine.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.cosine( 2.0, 5.0 )\n \n > r = base.random.cosine( 2.0, 5.0 )\n \n\n\nbase.random.cosine.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.cosine.stateLength;\n\n\nbase.random.cosine.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.cosine.byteLength;\n\n\nbase.random.cosine.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.cosine.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.discreteUniform,"\nbase.random.discreteUniform( a, b )\n Returns a pseudorandom number drawn from a discrete uniform distribution.\n\n If `a > b`, the function returns `NaN`.\n\n If `a` or `b` is not an integer value, the function returns `NaN`.\n\n Parameters\n ----------\n a: integer\n Minimum support.\n\n b: integer\n Maximum support.\n\n Returns\n -------\n r: integer\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.discreteUniform( 2, 50 );\n\n\nbase.random.discreteUniform.factory( [a, b, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a discrete uniform distribution.\n\n If provided `a` and `b`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `a` and `b`, the returned PRNG requires that both `a` and\n `b` be provided at each invocation.\n\n Parameters\n ----------\n a: integer (optional)\n Minimum support.\n\n b: integer (optional)\n Maximum support.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom integers. If provided, the `state` and `seed`\n options are ignored. In order to seed the returned pseudorandom number\n generator, one must seed the provided `prng` (assuming the provided\n `prng` is seedable). The provided PRNG must have `MIN` and `MAX`\n properties specifying the minimum and maximum possible pseudorandom\n integers.\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.discreteUniform.factory();\n > var r = rand( 0, 10 );\n > r = rand( -20, 20 );\n\n // Provide `a` and `b`:\n > rand = base.random.discreteUniform.factory( 0, 10 );\n > r = rand();\n > r = rand();\n\n\nbase.random.discreteUniform.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.discreteUniform.NAME\n 'discrete-uniform'\n\n\nbase.random.discreteUniform.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.discreteUniform.PRNG;\n\n\nbase.random.discreteUniform.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.discreteUniform.seed;\n\n\nbase.random.discreteUniform.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.discreteUniform.seedLength;\n\n\nbase.random.discreteUniform.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.discreteUniform( 2, 50 )\n \n > r = base.random.discreteUniform( 2, 50 )\n \n > r = base.random.discreteUniform( 2, 50 )\n \n\n // Get a copy of the current state:\n > var state = base.random.discreteUniform.state\n \n\n > r = base.random.discreteUniform( 2, 50 )\n \n > r = base.random.discreteUniform( 2, 50 )\n \n\n // Set the state:\n > base.random.discreteUniform.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.discreteUniform( 2, 50 )\n \n > r = base.random.discreteUniform( 2, 50 )\n \n\n\nbase.random.discreteUniform.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.discreteUniform.stateLength;\n\n\nbase.random.discreteUniform.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.discreteUniform.byteLength;\n\n\nbase.random.discreteUniform.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.discreteUniform.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.erlang,"\nbase.random.erlang( k, λ )\n Returns a pseudorandom number drawn from an Erlang distribution.\n\n If `k` is not a positive integer or `λ <= 0`, the function returns `NaN`.\n\n If `k` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n k: integer\n Shape parameter.\n\n λ: number\n Rate parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.erlang( 2, 5.0 );\n\n\nbase.random.erlang.factory( [k, λ, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from an Erlang distribution.\n\n If provided `k` and `λ`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `k` and `λ`, the returned PRNG requires that both `k` and\n `λ` be provided at each invocation.\n\n Parameters\n ----------\n k: integer (optional)\n Shape parameter.\n\n λ: number (optional)\n Rate parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.erlang.factory();\n > var r = rand( 2, 1.0 );\n > r = rand( 4, 3.14 );\n\n // Provide `k` and `λ`:\n > rand = base.random.erlang.factory( 2, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.erlang.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.erlang.NAME\n 'erlang'\n\n\nbase.random.erlang.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.erlang.PRNG;\n\n\nbase.random.erlang.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.erlang.seed;\n\n\nbase.random.erlang.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.erlang.seedLength;\n\n\nbase.random.erlang.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.erlang( 2, 5.0 )\n \n > r = base.random.erlang( 2, 5.0 )\n \n > r = base.random.erlang( 2, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.erlang.state\n \n\n > r = base.random.erlang( 2, 5.0 )\n \n > r = base.random.erlang( 2, 5.0 )\n \n\n // Set the state:\n > base.random.erlang.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.erlang( 2, 5.0 )\n \n > r = base.random.erlang( 2, 5.0 )\n \n\n\nbase.random.erlang.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.erlang.stateLength;\n\n\nbase.random.erlang.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.erlang.byteLength;\n\n\nbase.random.erlang.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.erlang.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.exponential,"\nbase.random.exponential( λ )\n Returns a pseudorandom number drawn from an exponential distribution.\n\n If `λ <= 0` or `λ` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n λ: number\n Rate parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.exponential( 7.9 );\n\n\nbase.random.exponential.factory( [λ, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from an exponential distribution.\n\n If provided `λ`, the returned PRNG returns random variates drawn from the\n specified distribution.\n\n If not provided `λ`, the returned PRNG requires that `λ` be provided at each\n invocation.\n\n Parameters\n ----------\n λ: number (optional)\n Rate parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.exponential.factory();\n > var r = rand( 5.0 );\n > r = rand( 3.14 );\n\n // Provide `λ`:\n > rand = base.random.exponential.factory( 10.0 );\n > r = rand();\n > r = rand();\n\n\nbase.random.exponential.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.exponential.NAME\n 'exponential'\n\n\nbase.random.exponential.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.exponential.PRNG;\n\n\nbase.random.exponential.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.exponential.seed;\n\n\nbase.random.exponential.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.exponential.seedLength;\n\n\nbase.random.exponential.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.exponential( 7.9 )\n \n > r = base.random.exponential( 7.9 )\n \n > r = base.random.exponential( 7.9 )\n \n\n // Get a copy of the current state:\n > var state = base.random.exponential.state\n \n\n > r = base.random.exponential( 7.9 )\n \n > r = base.random.exponential( 7.9 )\n \n\n // Set the state:\n > base.random.exponential.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.exponential( 7.9 )\n \n > r = base.random.exponential( 7.9 )\n \n\n\nbase.random.exponential.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.exponential.stateLength;\n\n\nbase.random.exponential.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.exponential.byteLength;\n\n\nbase.random.exponential.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.exponential.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.f,"\nbase.random.f( d1, d2 )\n Returns a pseudorandom number drawn from an F distribution.\n\n If `d1 <= 0` or `d2 <= 0`, the function returns `NaN`.\n\n If `d1` or `d2` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n d1: number\n Degrees of freedom.\n\n d2: number\n Degrees of freedom.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.f( 2.0, 5.0 );\n\n\nbase.random.f.factory( [d1, d2, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from an F distribution.\n\n If provided `d1` and `d2`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `d1` and `d2`, the returned PRNG requires that both `d1` and\n `d2` be provided at each invocation.\n\n Parameters\n ----------\n d1: number (optional)\n Degrees of freedom.\n\n d2: number (optional)\n Degrees of freedom.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.f.factory();\n > var r = rand( 1.5, 1.5 );\n > r = rand( 3.0, 3.14 );\n\n // Provide `d1` and `d2`:\n > rand = base.random.f.factory( 1.5, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.f.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.f.NAME\n 'f'\n\n\nbase.random.f.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.f.PRNG;\n\n\nbase.random.f.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.f.seed;\n\n\nbase.random.f.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.f.seedLength;\n\n\nbase.random.f.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.f( 1.5, 1.5 )\n \n > r = base.random.f( 1.5, 1.5 )\n \n > r = base.random.f( 1.5, 1.5 )\n \n\n // Get a copy of the current state:\n > var state = base.random.f.state\n \n\n > r = base.random.f( 1.5, 1.5 )\n \n > r = base.random.f( 1.5, 1.5 )\n \n\n // Set the state:\n > base.random.f.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.f( 1.5, 1.5 )\n \n > r = base.random.f( 1.5, 1.5 )\n \n\n\nbase.random.f.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.f.stateLength;\n\n\nbase.random.f.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.f.byteLength;\n\n\nbase.random.f.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.f.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.frechet,"\nbase.random.frechet( α, s, m )\n Returns a pseudorandom number drawn from a Fréchet distribution.\n\n If provided `α <= 0` or `s <= 0`, the function returns `NaN`.\n\n If either `α`, `s`, or `m` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n s: number\n Scale parameter.\n\n m: number\n Location parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.frechet( 2.0, 5.0, 3.33 );\n\n\nbase.random.frechet.factory( [α, s, m, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a triangular distribution.\n\n If provided `α`, `s`, and `m`, the returned PRNG returns random variates\n drawn from the specified distribution.\n\n If not provided `α`, `s`, and `m`, the returned PRNG requires that `α`, `s`,\n and `m` be provided at each invocation.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter.\n\n s: number (optional)\n Scale parameter.\n\n m: number (optional)\n Location parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.frechet.factory();\n > var r = rand( 1.0, 1.0, 0.5 );\n > r = rand( 2.0, 2.0, 1.0 );\n\n // Provide `α`, `s`, and `m`:\n > rand = base.random.frechet.factory( 1.0, 1.0, 0.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.frechet.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.frechet.NAME\n 'frechet'\n\n\nbase.random.frechet.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.frechet.PRNG;\n\n\nbase.random.frechet.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.frechet.seed;\n\n\nbase.random.frechet.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.frechet.seedLength;\n\n\nbase.random.frechet.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n\n // Get a copy of the current state:\n > var state = base.random.frechet.state\n \n\n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n\n // Set the state:\n > base.random.frechet.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n > r = base.random.frechet( 1.0, 1.0, 0.5 )\n \n\n\nbase.random.frechet.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.frechet.stateLength;\n\n\nbase.random.frechet.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.frechet.byteLength;\n\n\nbase.random.frechet.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.frechet.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.gamma,"\nbase.random.gamma( α, β )\n Returns a pseudorandom number drawn from a gamma distribution.\n\n If `α <= 0` or `β <= 0`, the function returns `NaN`.\n\n If `α` or `β` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n α: number\n Shape parameter.\n\n β: number\n Rate parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.gamma( 2.0, 5.0 );\n\n\nbase.random.gamma.factory( [α, β, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a gamma distribution.\n\n If provided `α` and `β`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `α` and `β`, the returned PRNG requires that both `α` and\n `β` be provided at each invocation.\n\n Parameters\n ----------\n α: number (optional)\n Shape parameter.\n\n β: number (optional)\n Rate parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.gamma.factory();\n > var r = rand( 1.5, 1.5 );\n > r = rand( 3.14, 2.25 );\n\n // Provide `α` and `β`:\n > rand = base.random.gamma.factory( 1.5, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.gamma.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.gamma.NAME\n 'gamma'\n\n\nbase.random.gamma.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.gamma.PRNG;\n\n\nbase.random.gamma.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.gamma.seed;\n\n\nbase.random.gamma.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.gamma.seedLength;\n\n\nbase.random.gamma.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.gamma( 2.0, 5.0 )\n \n > r = base.random.gamma( 2.0, 5.0 )\n \n > r = base.random.gamma( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.gamma.state\n \n\n > r = base.random.gamma( 2.0, 5.0 )\n \n > r = base.random.gamma( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.gamma.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.gamma( 2.0, 5.0 )\n \n > r = base.random.gamma( 2.0, 5.0 )\n \n\n\nbase.random.gamma.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.gamma.stateLength;\n\n\nbase.random.gamma.byteLength\n Size of generator state.\n\n Examples\n --------\n > var sz = base.random.gamma.byteLength;\n\n\nbase.random.gamma.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.gamma.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.geometric,"\nbase.random.geometric( p )\n Returns a pseudorandom number drawn from a geometric distribution.\n\n If `p < 0` or `p > 1` or `p` is `NaN`, the function returns `NaN`.\n\n Parameters\n ----------\n p: number\n Success probability.\n\n Returns\n -------\n r: integer\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.geometric( 0.8 );\n\n\nbase.random.geometric.factory( [p, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a geometric distribution.\n\n If provided `p`, the returned PRNG returns random variates drawn from the\n specified distribution.\n\n If not provided `p`, the returned PRNG requires that `p` be provided at each\n invocation.\n\n Parameters\n ----------\n p: number (optional)\n Success probability.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.geometric.factory();\n > var r = rand( 0.3 );\n > r = rand( 0.59 );\n\n // Provide `p`:\n > rand = base.random.geometric.factory( 0.3 );\n > r = rand();\n > r = rand();\n\n\nbase.random.geometric.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.geometric.NAME\n 'geometric'\n\n\nbase.random.geometric.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.geometric.PRNG;\n\n\nbase.random.geometric.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.geometric.seed;\n\n\nbase.random.geometric.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.geometric.seedLength;\n\n\nbase.random.geometric.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.geometric( 0.3 )\n \n > r = base.random.geometric( 0.3 )\n \n > r = base.random.geometric( 0.3 )\n \n\n // Get a copy of the current state:\n > var state = base.random.geometric.state\n \n\n > r = base.random.geometric( 0.3 )\n \n > r = base.random.geometric( 0.3 )\n \n\n // Set the state:\n > base.random.geometric.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.geometric( 0.3 )\n \n > r = base.random.geometric( 0.3 )\n \n\n\nbase.random.geometric.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.geometric.stateLength;\n\n\nbase.random.geometric.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.geometric.byteLength;\n\n\nbase.random.geometric.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.geometric.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.gumbel,"\nbase.random.gumbel( μ, β )\n Returns a pseudorandom number drawn from a Gumbel distribution.\n\n If `μ` or `β` is `NaN` or `β <= 0`, the function returns `NaN`.\n\n Parameters\n ----------\n μ: number\n Mean.\n\n β: number\n Scale parameter.\n\n Returns\n -------\n r: number\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.gumbel( 2.0, 5.0 );\n\n\nbase.random.gumbel.factory( [μ, β, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a Gumbel distribution.\n\n If provided `μ` and `β`, the returned PRNG returns random variates drawn\n from the specified distribution.\n\n If not provided `μ` and `β`, the returned PRNG requires that both `μ` and\n `β` be provided at each invocation.\n\n Parameters\n ----------\n μ: number (optional)\n Mean.\n\n β: number (optional)\n Scale parameter.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject (optional)\n Pseudorandom number generator seed. The seed may be either a positive\n unsigned 32-bit integer or, for arbitrary length seeds, an array-like\n object containing unsigned 32-bit integers.\n\n options.state: Uint32Array (optional)\n Pseudorandom number generator state. If provided, the `seed` option is\n ignored.\n\n options.copy: boolean (optional)\n Boolean indicating whether to copy a provided pseudorandom number\n generator state. Setting this option to `false` allows sharing state\n between two or more pseudorandom number generators. Setting this option\n to `true` ensures that a returned generator has exclusive control over\n its internal state. Default: true.\n\n Returns\n -------\n rand: Function\n Pseudorandom number generator (PRNG).\n\n Examples\n --------\n // Basic usage:\n > var rand = base.random.gumbel.factory();\n > var r = rand( 0.1, 1.5 );\n > r = rand( 2.0, 3.14 );\n\n // Provide `μ` and `β`:\n > rand = base.random.gumbel.factory( 0.1, 1.5 );\n > r = rand();\n > r = rand();\n\n\nbase.random.gumbel.NAME\n Generator name.\n\n Examples\n --------\n > var str = base.random.gumbel.NAME\n 'gumbel'\n\n\nbase.random.gumbel.PRNG\n Underlying pseudorandom number generator.\n\n Examples\n --------\n > var prng = base.random.gumbel.PRNG;\n\n\nbase.random.gumbel.seed\n Pseudorandom number generator seed.\n\n Examples\n --------\n > var seed = base.random.gumbel.seed;\n\n\nbase.random.gumbel.seedLength\n Length of generator seed.\n\n Examples\n --------\n > var len = base.random.gumbel.seedLength;\n\n\nbase.random.gumbel.state\n Generator state.\n\n Examples\n --------\n > var r = base.random.gumbel( 2.0, 5.0 )\n \n > r = base.random.gumbel( 2.0, 5.0 )\n \n > r = base.random.gumbel( 2.0, 5.0 )\n \n\n // Get a copy of the current state:\n > var state = base.random.gumbel.state\n \n\n > r = base.random.gumbel( 2.0, 5.0 )\n \n > r = base.random.gumbel( 2.0, 5.0 )\n \n\n // Set the state:\n > base.random.gumbel.state = state;\n\n // Replay the last two pseudorandom numbers:\n > r = base.random.gumbel( 2.0, 5.0 )\n \n > r = base.random.gumbel( 2.0, 5.0 )\n \n\n\nbase.random.gumbel.stateLength\n Length of generator state.\n\n Examples\n --------\n > var len = base.random.gumbel.stateLength;\n\n\nbase.random.gumbel.byteLength\n Size (in bytes) of generator state.\n\n Examples\n --------\n > var sz = base.random.gumbel.byteLength;\n\n\nbase.random.gumbel.toJSON()\n Serializes the pseudorandom number generator as a JSON object.\n\n Returns\n -------\n out: Object\n JSON representation.\n\n Examples\n --------\n > var o = base.random.gumbel.toJSON()\n { 'type': 'PRNG', 'name': '...', 'state': {...}, 'params': [] }\n\n"
+base.random.hypergeometric,"\nbase.random.hypergeometric( N, K, n )\n Returns a pseudorandom number drawn from a hypergeometric distribution.\n\n `N`, `K`, and `n` must all be nonnegative integers; otherwise, the function\n returns `NaN`.\n\n If `n > N` or `K > N`, the function returns `NaN`.\n\n Parameters\n ----------\n N: integer\n Population size.\n\n K: integer\n Subpopulation size.\n\n n: integer\n Number of draws.\n\n Returns\n -------\n r: integer\n Pseudorandom number.\n\n Examples\n --------\n > var r = base.random.hypergeometric( 20, 10, 7 );\n\n\nbase.random.hypergeometric.factory( [N, K, n, ][options] )\n Returns a pseudorandom number generator (PRNG) for generating pseudorandom\n numbers drawn from a hypergeometric distribution.\n\n If provided `N`, `K`, and `n`, the returned PRNG returns random variates\n drawn from the specified distribution.\n\n If not provided `N`, `K`, and `n`, the returned PRNG requires that `N`, `K`,\n and `n` be provided at each invocation.\n\n Parameters\n ----------\n N: integer (optional)\n Population size.\n\n K: integer (optional)\n Subpopulation size.\n\n n: integer (optional)\n Number of draws.\n\n options: Object (optional)\n Options.\n\n options.prng: Function (optional)\n Pseudorandom number generator (PRNG) for generating uniformly\n distributed pseudorandom numbers on the interval `[0,1)`. If provided,\n the `state` and `seed` options are ignored. In order to seed the\n returned pseudorandom number generator, one must seed the provided\n `prng` (assuming the provided `prng` is seedable).\n\n options.seed: integer|ArrayLikeObject
+