@stdlib/math-tools-unary 0.2.2 → 0.3.0

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../lib/ndarray.js", "../lib/resolve_output_dtype.js", "../lib/defaults.json", "../lib/validate_table.js", "../lib/policies.json", "../lib/validate_options.js", "../lib/validate.js", "../lib/main.js", "../lib/index.js"],
-  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar ndarray = require( '@stdlib/ndarray-ctor' );\nvar buffer = require( '@stdlib/ndarray-base-buffer' );\nvar shape2strides = require( '@stdlib/ndarray-base-shape2strides' );\nvar numel = require( '@stdlib/ndarray-base-numel' );\nvar copy = require( '@stdlib/array-base-copy-indexed' );\n\n\n// MAIN //\n\n/**\n* Applies a function to an ndarray.\n*\n* @private\n* @param {Function} fcn - function to apply\n* @param {ndarray} x - input array\n* @param {string} ydtype - output array data type\n* @param {string} yorder - output array order\n* @returns {ndarray} output array\n*/\nfunction ndarrayfcn( fcn, x, ydtype, yorder ) {\n\tvar shape;\n\tvar buf;\n\tvar y;\n\n\t// Check if we were provided a zero-dimensional array...\n\tshape = copy( x.shape ); // Note: we need to copy the shape to avoid a shared shape object between `x` and `y` which could lead to unintended mutations (e.g., if either `x` or `y` is reshaped)\n\tif ( shape.length === 0 ) {\n\t\tbuf = buffer( ydtype, 1 );\n\t\ty = ndarray( ydtype, buf, [], [ 0 ], 0, yorder );\n\t} else {\n\t\tbuf = buffer( ydtype, x.length || numel( shape ) ); // WARNING: `x.length` is a property found on ndarray instances, but not strictly necessary to describe an ndarray; accordingly, used here to avoid unnecessary computation, but a potential source of bugs if provided an ndarray-like object having a `length` property which is not equal to the product of the dimensions.\n\t\ty = ndarray( ydtype, buf, shape, shape2strides( shape, yorder ), 0, yorder ); // eslint-disable-line max-len\n\t}\n\tfcn( x, y );\n\treturn y;\n}\n\n\n// EXPORTS //\n\nmodule.exports = ndarrayfcn;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar format = require( '@stdlib/string-format' );\n\n\n// MAIN //\n\n/**\n* Resolves an output array data type.\n*\n* @private\n* @param {string} xdtype - input array data type\n* @param {string} policy - policy determining an output array data type\n* @throws {Error} unsupported policy\n* @returns {string} output array data type\n*/\nfunction resolve( xdtype, policy ) {\n\tswitch ( policy ) {\n\tcase 'same':\n\t\treturn xdtype;\n\tcase 'floating-point':\n\t\t// TODO: we may want to delegate checking for a floating-point dtype to a utility function/package (e.g., isFloatDtype), in order to centralize logic for testing whether a dtype is \"floating-point\". Otherwise, this will be yet another place to update logic should we ever add, e.g., a `float128` or `float16` dtype.\n\t\tif (\n\t\t\txdtype === 'float64' ||\n\t\t\txdtype === 'float32' ||\n\t\t\txdtype === 'generic' ||\n\t\t\txdtype === 'complex128' ||\n\t\t\txdtype === 'complex64'\n\t\t) {\n\t\t\treturn xdtype;\n\t\t}\n\t\treturn 'float64'; // TODO: constants/math/default-real-floating-point-dtype?\n\tcase 'real floating-point':\n\t\tif (\n\t\t\txdtype === 'float64' ||\n\t\t\txdtype === 'float32' ||\n\t\t\txdtype === 'generic'\n\t\t) {\n\t\t\treturn xdtype;\n\t\t}\n\t\treturn 'float64';\n\tcase 'complex floating-point':\n\t\tif (\n\t\t\txdtype === 'complex128' ||\n\t\t\txdtype === 'complex64'\n\t\t) {\n\t\t\treturn xdtype;\n\t\t}\n\t\treturn 'complex128'; // TODO: constants/math/default-complex-floating-point-dtype?\n\tdefault:\n\t\tthrow new Error( format( 'invalid option. Unsupported policy for determining an output array data type. Option: `%s`.', policy ) );\n\t}\n}\n\n\n// EXPORTS //\n\nmodule.exports = resolve;\n", "{\n\t\"output_dtype_policy\": \"floating-point\"\n}\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isPlainObject = require( '@stdlib/assert-is-plain-object' );\nvar hasOwnProp = require( '@stdlib/assert-has-own-property' );\nvar isFunction = require( '@stdlib/assert-is-function' );\nvar isNull = require( '@stdlib/assert-is-null' );\nvar objectKeys = require( '@stdlib/utils-keys' );\nvar format = require( '@stdlib/string-format' );\n\n\n// MAIN //\n\n/**\n* Validates a resolution table object.\n*\n* @private\n* @param {Object} out - destination object\n* @param {Object} table - resolution table object\n* @param {(Function|null)} [table.number] - function to invoke upon receiving a number\n* @param {(Function|null)} [table.complex] - function to invoke upon receiving a complex number\n* @param {(Function|null)} [table.array] - function to invoke upon receiving an array-like object\n* @param {(Function|null)} [table.ndarray] - function to invoke upon receiving an ndarray-like object\n* @returns {(Error|null)} null or an error object\n*\n* @example\n* var out = {};\n* var table = {\n*     'number': null,\n*     'complex': null,\n*     'array': null,\n*     'ndarray': null\n* };\n* var err = validate( out, table );\n* if ( err ) {\n*     throw err;\n* }\n*/\nfunction validate( out, table ) {\n\tvar fields;\n\tvar tmp;\n\tvar key;\n\tvar i;\n\n\tif ( !isPlainObject( table ) ) {\n\t\treturn new TypeError( format( 'invalid argument. Resolution table must be an object. Value: `%s`.', table ) );\n\t}\n\tfields = objectKeys( out );\n\tfor ( i = 0; i < fields.length; i++ ) {\n\t\tkey = fields[ i ];\n\t\tif ( hasOwnProp( table, key ) ) {\n\t\t\ttmp = table[ key ];\n\t\t\tif ( !isFunction( tmp ) && !isNull( tmp ) ) {\n\t\t\t\treturn new TypeError( format( 'invalid argument. Resolution table `%s` field value must be either a function or null. Value: `%s`.', key, tmp ) );\n\t\t\t}\n\t\t\tout[ key ] = tmp;\n\t\t}\n\t}\n\treturn null;\n}\n\n\n// EXPORTS //\n\nmodule.exports = validate;\n", "[\n\t\"same\",\n\t\"floating-point\",\n  \"real floating-point\",\n  \"complex floating-point\"\n]\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isPlainObject = require( '@stdlib/assert-is-plain-object' );\nvar hasOwnProp = require( '@stdlib/assert-has-own-property' );\nvar contains = require( '@stdlib/assert-contains' );\nvar format = require( '@stdlib/string-format' );\nvar POLICIES = require( './policies.json' );\n\n\n// MAIN //\n\n/**\n* Validates function options.\n*\n* @private\n* @param {Object} opts - destination object\n* @param {Object} options - options\n* @param {string} [options.output_dtype_policy] - policy for determining the output array data type\n* @returns {(Error|null)} null or an error object\n*\n* @example\n* var opts = {};\n* var options = {\n*     'output_dtype_policy': 'float'\n* };\n* var err = validate( opts, options );\n* if ( err ) {\n*     throw err;\n* }\n*/\nfunction validate( opts, options ) {\n\tif ( !isPlainObject( options ) ) {\n\t\treturn new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );\n\t}\n\tif ( hasOwnProp( options, 'output_dtype_policy' ) ) {\n\t\topts.policy = options.output_dtype_policy;\n\t\tif ( !contains( POLICIES, opts.policy ) ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be a recognized/supported output array data type policy. Option: `%s`.', 'output_dtype_policy', opts.policy ) );\n\t\t}\n\t}\n\treturn null;\n}\n\n\n// EXPORTS //\n\nmodule.exports = validate;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isPlainObject = require( '@stdlib/assert-is-plain-object' );\nvar hasOwnProp = require( '@stdlib/assert-has-own-property' );\nvar contains = require( '@stdlib/assert-contains' );\nvar orders = require( '@stdlib/ndarray-orders' );\nvar dtypes = require( '@stdlib/ndarray-dtypes' );\nvar format = require( '@stdlib/string-format' );\n\n\n// VARIABLES //\n\nvar ORDERS = orders();\nvar DTYPES = dtypes();\n\n\n// MAIN //\n\n/**\n* Validates function options.\n*\n* @private\n* @param {Object} opts - destination object\n* @param {Object} options - options\n* @param {string} [options.dtype] - output array data type\n* @param {string} [options.order] - output array order\n* @returns {(Error|null)} null or an error object\n*\n* @example\n* var opts = {};\n* var options = {\n*     'order': 'row-major'\n* };\n* var err = validate( opts, options );\n* if ( err ) {\n*     throw err;\n* }\n*/\nfunction validate( opts, options ) {\n\tif ( !isPlainObject( options ) ) {\n\t\treturn new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );\n\t}\n\tif ( hasOwnProp( options, 'dtype' ) ) {\n\t\topts.dtype = options.dtype;\n\t\tif ( !contains( DTYPES, opts.dtype ) ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.', 'dtype', opts.dtype ) );\n\t\t}\n\t}\n\tif ( hasOwnProp( options, 'order' ) ) {\n\t\topts.order = options.order;\n\t\tif ( !contains( ORDERS, opts.order ) ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.', 'order', opts.order ) );\n\t\t}\n\t}\n\treturn null;\n}\n\n\n// EXPORTS //\n\nmodule.exports = validate;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar isNumber = require( '@stdlib/assert-is-number' ).isPrimitive;\nvar isComplexLike = require( '@stdlib/assert-is-complex-like' );\nvar isndarrayLike = require( '@stdlib/assert-is-ndarray-like' );\nvar isCollection = require( '@stdlib/assert-is-collection' );\nvar dtype = require( '@stdlib/ndarray-base-buffer-dtype' );\nvar buffer = require( '@stdlib/ndarray-base-buffer' );\nvar broadcast = require( '@stdlib/ndarray-base-broadcast-array' );\nvar format = require( '@stdlib/string-format' );\nvar ndarrayfcn = require( './ndarray.js' );\nvar odtype = require( './resolve_output_dtype.js' );\nvar defaults = require( './defaults.json' );\nvar validateTable = require( './validate_table.js' );\nvar validateOptions = require( './validate_options.js' );\nvar validate = require( './validate.js' );\n\n\n// MAIN //\n\n/**\n* Returns a function which dispatches to specified functions based on input argument types.\n*\n* @param {Object} table - resolution table object\n* @param {(Function|null)} [table.number] - function to invoke upon receiving a number\n* @param {(Function|null)} [table.complex] - function to invoke upon receiving a complex number\n* @param {(Function|null)} [table.array] - function to invoke upon receiving an array-like object\n* @param {(Function|null)} [table.ndarray] - function to invoke upon receiving an ndarray-like object\n* @param {Options} [options] - options\n* @param {string} [options.output_dtype_policy='floating-point'] - policy for determining the output array data type\n* @throws {TypeError} first argument must be an object\n* @throws {TypeError} first argument must have valid table fields\n* @throws {Error} each table field value must be either a function or `null`\n* @throws {TypeError} options argument must be an object\n* @throws {TypeError} must provide valid options\n* @returns {Function} dispatch function\n*\n* @example\n* var base = require( '@stdlib/math-base-special-abs' );\n* var strided = require( '@stdlib/math-strided-special-abs' );\n* var dispatcher = require( '@stdlib/ndarray-dispatch' );\n* var unary = require( '@stdlib/ndarray-base-unary' );\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* var types = [\n*     'float64', 'float64',\n*     'float32', 'float32',\n*     'generic', 'generic'\n* ];\n* var data = [\n*     base,\n*     base,\n*     base\n* ];\n* var nd = dispatcher( unary, types, data, 2, 1, 1 );\n*\n* var table = {\n*     'number': base,\n*     'complex': null,\n*     'array': strided,\n*     'ndarray': nd\n* };\n*\n* var abs = dispatch( table, {\n*     'output_dtype_policy': 'same'\n* });\n*\n* var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );\n*\n* var y = abs( x );\n* // returns <Float64Array>[ 1.0, 2.0, 3.0 ]\n*/\nfunction dispatch( table, options ) {\n\tvar OPTS;\n\tvar err;\n\tvar fcn;\n\tvar t;\n\n\tt = {\n\t\t'number': null,\n\t\t'complex': null,\n\t\t'array': null,\n\t\t'ndarray': null\n\t};\n\terr = validateTable( t, table );\n\tif ( err ) {\n\t\tthrow err;\n\t}\n\tOPTS = {\n\t\t'policy': defaults.output_dtype_policy\n\t};\n\tif ( arguments.length > 1 ) {\n\t\terr = validateOptions( OPTS, options );\n\t\tif ( err ) {\n\t\t\tthrow err;\n\t\t}\n\t}\n\tfcn = dispatcher;\n\tsetReadOnly( fcn, 'assign', assign );\n\treturn fcn;\n\n\t/**\n\t* Function interface which performs dispatch.\n\t*\n\t* @private\n\t* @param {(ndarray|Collection|number|Complex)} x - input value\n\t* @param {Options} [options] - options\n\t* @param {string} [options.dtype] - output array data type\n\t* @param {string} [options.order] - output array order (row-major or column-major)\n\t* @throws {TypeError} first argument must be a supported data type\n\t* @throws {TypeError} options argument must be an object\n\t* @throws {TypeError} must provide valid options\n\t* @returns {(ndarray|Collection|number|Complex)} results\n\t*/\n\tfunction dispatcher( x ) {\n\t\tvar xdtype;\n\t\tvar ydtype;\n\t\tvar opts;\n\t\tvar err;\n\t\tvar y;\n\t\tif ( isNumber( x ) ) {\n\t\t\tif ( t.number ) {\n\t\t\t\treturn t.number( x );\n\t\t\t}\n\t\t\tthrow new TypeError( 'invalid argument. Providing a number is not supported.' );\n\t\t}\n\t\tif ( isComplexLike( x ) ) {\n\t\t\tif ( t.complex ) {\n\t\t\t\treturn t.complex( x );\n\t\t\t}\n\t\t\tthrow new TypeError( 'invalid argument. Providing a complex number is not supported.' );\n\t\t}\n\t\topts = {};\n\t\tif ( arguments.length > 1 ) {\n\t\t\terr = validate( opts, arguments[ 1 ] );\n\t\t\tif ( err ) {\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\t\tif ( isndarrayLike( x ) ) {\n\t\t\tif ( t.ndarray === null ) {\n\t\t\t\tthrow new TypeError( 'invalid argument. Providing an ndarray is not supported.' );\n\t\t\t}\n\t\t\tydtype = opts.dtype || odtype( x.dtype, OPTS.policy );\n\t\t\treturn ndarrayfcn( t.ndarray, x, ydtype, opts.order || x.order );\n\t\t}\n\t\tif ( isCollection( x ) ) {\n\t\t\tif ( t.array === null ) {\n\t\t\t\tthrow new TypeError( 'invalid argument. Providing an array-like object is not supported.' );\n\t\t\t}\n\t\t\txdtype = dtype( x ) || 'generic';\n\t\t\tydtype = opts.dtype || odtype( xdtype, OPTS.policy );\n\t\t\ty = buffer( ydtype, x.length );\n\t\t\tt.array( x.length, xdtype, x, 1, ydtype, y, 1 );\n\t\t\treturn y;\n\t\t}\n\t\tthrow new TypeError( format( 'invalid argument. Must provide an argument having a supported data type. Value: `%s`.', x ) );\n\t}\n\n\t/**\n\t* Function interface which performs dispatch and assigns results to a provided output array.\n\t*\n\t* @private\n\t* @param {(ndarray|Collection)} x - input array\n\t* @param {(ndarray|Collection)} y - output array\n\t* @throws {TypeError} first argument must be a supported data type\n\t* @throws {TypeError} second argument must be a supported data type\n\t* @throws {TypeError} first and second argument must be the same \"kind\" (i.e., either both ndarrays or both collections)\n\t* @throws {RangeError} output array must have sufficient elements\n\t* @throws {Error} unable to broadcast the input array against the output array\n\t* @returns {(ndarray|Collection)} output array\n\t*/\n\tfunction assign( x, y ) {\n\t\tvar xsh;\n\t\tvar ysh;\n\t\tvar i;\n\t\tif ( isndarrayLike( x ) ) {\n\t\t\tif ( isndarrayLike( y ) ) {\n\t\t\t\txsh = x.shape;\n\t\t\t\tysh = y.shape;\n\n\t\t\t\t// Check whether we need to broadcast `x`...\n\t\t\t\tif ( xsh.length === ysh.length ) {\n\t\t\t\t\tfor ( i = 0; i < xsh.length; i++ ) {\n\t\t\t\t\t\t// Check whether dimensions match...\n\t\t\t\t\t\tif ( xsh[ i ] !== ysh[ i ] ) {\n\t\t\t\t\t\t\t// We found a mismatched dimension; delegate to `broadcast` to ensure that `x` is broadcast compatible with the output array shape...\n\t\t\t\t\t\t\tx = broadcast( x, ysh );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// If we are provided arrays with different ranks (i.e., number of dimensions), assume we need to broadcast, delegating to `broadcast` to ensure that `x` is broadcast compatible with the output array shape...\n\t\t\t\t\tx = broadcast( x, ysh );\n\t\t\t\t}\n\t\t\t\tt.ndarray( x, y );\n\t\t\t\treturn y;\n\t\t\t}\n\t\t\tthrow new TypeError( 'invalid argument. If the first argument is an ndarray, the second argument must be an ndarray.' );\n\t\t}\n\t\tif ( isCollection( x ) ) {\n\t\t\tif ( isCollection( y ) ) {\n\t\t\t\tif ( y.length !== x.length ) {\n\t\t\t\t\tthrow new RangeError( 'invalid argument. Output array must have the same number of elements (i.e., length) as the input array.' );\n\t\t\t\t}\n\t\t\t\tt.array( x.length, dtype( x ) || 'generic', x, 1, dtype( y ) || 'generic', y, 1 );\n\t\t\t\treturn y;\n\t\t\t}\n\t\t\tthrow new TypeError( 'invalid argument. If the first argument is an array-like object, the second argument must be an array-like object.' );\n\t\t}\n\t\tif ( isNumber( x ) ) {\n\t\t\tthrow new TypeError( 'invalid argument. Providing a number is not supported. Consider providing a zero-dimensional ndarray containing the numeric value.' );\n\t\t}\n\t\tif ( isComplexLike( x ) ) {\n\t\t\tthrow new TypeError( 'invalid argument. Providing a complex number is not supported. Consider providing a zero-dimensional ndarray containing the complex number value.' );\n\t\t}\n\t\tthrow new TypeError( format( 'invalid argument. Must provide an argument having a supported data type. Value: `%s`.', x ) );\n\t}\n}\n\n\n// EXPORTS //\n\nmodule.exports = dispatch;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Return a function which dispatches to specified functions based on input argument types.\n*\n* @module @stdlib/math-tools-unary\n*\n* @example\n* var base = require( '@stdlib/math-base-special-abs' );\n* var strided = require( '@stdlib/math-strided-special-abs' );\n* var dispatcher = require( '@stdlib/ndarray-dispatch' );\n* var unary = require( '@stdlib/ndarray-base-unary' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var dispatch = require( '@stdlib/math-tools-unary' );\n*\n* var types = [\n*     'float64', 'float64',\n*     'float32', 'float32',\n*     'generic', 'generic'\n* ];\n* var data = [\n*     base,\n*     base,\n*     base\n* ];\n* var nd = dispatcher( unary, types, data, 2, 1, 1 );\n*\n* var table = {\n*     'number': base,\n*     'complex': null,\n*     'array': strided,\n*     'ndarray': nd\n* };\n*\n* var abs = dispatch( table );\n*\n* var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );\n* var y = abs( x );\n* // returns <Float64Array>[ 1.0, 2.0, 3.0 ]\n*/\n\n// MAIN //\n\nvar main = require( './main.js' );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n"],
-  "mappings": "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",
-  "names": ["require_ndarray", "__commonJSMin", "exports", "module", "ndarray", "buffer", "shape2strides", "numel", "copy", "ndarrayfcn", "fcn", "x", "ydtype", "yorder", "shape", "buf", "y", "require_resolve_output_dtype", "__commonJSMin", "exports", "module", "format", "resolve", "xdtype", "policy", "require_defaults", "__commonJSMin", "exports", "module", "require_validate_table", "__commonJSMin", "exports", "module", "isPlainObject", "hasOwnProp", "isFunction", "isNull", "objectKeys", "format", "validate", "out", "table", "fields", "tmp", "key", "require_policies", "__commonJSMin", "exports", "module", "require_validate_options", "__commonJSMin", "exports", "module", "isPlainObject", "hasOwnProp", "contains", "format", "POLICIES", "validate", "opts", "options", "require_validate", "__commonJSMin", "exports", "module", "isPlainObject", "hasOwnProp", "contains", "orders", "dtypes", "format", "ORDERS", "DTYPES", "validate", "opts", "options", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "isNumber", "isComplexLike", "isndarrayLike", "isCollection", "dtype", "buffer", "broadcast", "format", "ndarrayfcn", "odtype", "defaults", "validateTable", "validateOptions", "validate", "dispatch", "table", "options", "OPTS", "err", "fcn", "t", "dispatcher", "assign", "x", "xdtype", "ydtype", "opts", "y", "xsh", "ysh", "i", "main"]
+  "sources": ["../lib/validate.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isPlainObject = require( '@stdlib/assert-is-plain-object' );\nvar hasOwnProp = require( '@stdlib/assert-has-own-property' );\nvar isOrder = require( '@stdlib/ndarray-base-assert-is-order' );\nvar contains = require( '@stdlib/array-base-assert-contains' );\nvar orders = require( '@stdlib/ndarray-orders' );\nvar join = require( '@stdlib/array-base-join' );\nvar format = require( '@stdlib/string-format' );\n\n\n// MAIN //\n\n/**\n* Validates function options.\n*\n* @private\n* @param {Object} opts - destination object\n* @param {Array} dtypes - list of supported output data types\n* @param {Object} options - options\n* @param {*} [options.dtype] - output array data type\n* @param {string} [options.order] - output array order\n* @returns {(Error|null)} null or an error object\n*\n* @example\n* var dtypes = [ 'float64', 'float32', 'generic' ];\n*\n* var opts = {};\n* var options = {\n*     'order': 'row-major'\n* };\n* var err = validate( opts, dtypes, options );\n* if ( err ) {\n*     throw err;\n* }\n*/\nfunction validate( opts, dtypes, options ) {\n\tif ( !isPlainObject( options ) ) {\n\t\treturn new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );\n\t}\n\tif ( hasOwnProp( options, 'dtype' ) ) {\n\t\topts.dtype = options.dtype;\n\t\tif ( !contains( dtypes, String( opts.dtype ) ) ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be one of the following: \"%s\". Option: `%s`.', 'dtype', join( dtypes, '\", \"' ), opts.dtype ) );\n\t\t}\n\t}\n\tif ( hasOwnProp( options, 'order' ) ) {\n\t\topts.order = options.order;\n\t\tif ( !isOrder( opts.order ) ) {\n\t\t\treturn new TypeError( format( 'invalid option. `%s` option must be one of the following: \"%s\". Option: `%s`.', 'order', join( orders(), '\", \"' ), opts.order ) );\n\t\t}\n\t}\n\treturn null;\n}\n\n\n// EXPORTS //\n\nmodule.exports = validate;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar isndarrayLike = require( '@stdlib/assert-is-ndarray-like' );\nvar isFunction = require( '@stdlib/assert-is-function' );\nvar isObject = require( '@stdlib/assert-is-object' );\nvar isCollection = require( '@stdlib/assert-is-collection' );\nvar isOutputDataTypePolicy = require( '@stdlib/ndarray-base-assert-is-output-data-type-policy' );\nvar isInputCastingPolicy = require( '@stdlib/ndarray-base-assert-is-input-casting-policy' );\nvar isDataType = require( '@stdlib/ndarray-base-assert-is-data-type' );\nvar contains = require( '@stdlib/array-base-assert-contains' );\nvar unaryOutputDataType = require( '@stdlib/ndarray-base-unary-output-dtype' );\nvar unaryInputCastingDataType = require( '@stdlib/ndarray-base-unary-input-casting-dtype' );\nvar baseAssign = require( '@stdlib/ndarray-base-assign' );\nvar baseEmpty = require( '@stdlib/ndarray-base-empty' );\nvar maybeBroadcastArray = require( '@stdlib/ndarray-maybe-broadcast-array' );\nvar getShape = require( '@stdlib/ndarray-shape' );\nvar getOrder = require( '@stdlib/ndarray-order' );\nvar getDType = require( '@stdlib/ndarray-dtype' );\nvar empty = require( '@stdlib/ndarray-empty' );\nvar everyBy = require( '@stdlib/array-base-every-by' );\nvar join = require( '@stdlib/array-base-join' );\nvar format = require( '@stdlib/string-format' );\nvar validate = require( './validate.js' );\n\n\n// MAIN //\n\n/**\n* Returns a function which performs element-wise computation.\n*\n* @param {Function} fcn - function which applies a unary function to each element in an ndarray\n* @param {ArrayLikeObject<StringArray>} idtypes - list containing lists of supported input data types for each ndarray argument\n* @param {StringArray} odtypes - list of supported output data types\n* @param {Object} policies - dispatch policies\n* @param {string} policies.output - output data type policy\n* @param {string} policies.casting - input ndarray casting policy\n* @throws {TypeError} first argument must be a function\n* @throws {TypeError} second argument must be an array containing arrays of supported data types\n* @throws {TypeError} third argument must be an array of supported data types\n* @throws {TypeError} fourth argument must be an object having supported policies\n* @returns {Function} function which performs element-wise computation\n*\n* @example\n* var base = require( '@stdlib/math-base-special-abs' );\n* var dispatch = require( '@stdlib/ndarray-dispatch' );\n* var unary = require( '@stdlib/ndarray-base-unary' );\n* var ndarray2array = require( '@stdlib/ndarray-to-array' );\n* var array = require( '@stdlib/ndarray-array' );\n*\n* var types = [\n*     'float64', 'float64',\n*     'float32', 'float32',\n*     'generic', 'generic'\n* ];\n* var data = [\n*     base,\n*     base,\n*     base\n* ];\n* var dispatcher = dispatch( unary, types, data, 2, 1, 1 );\n*\n* var idt = [ 'float64', 'float32', 'generic' ];\n* var odt = idt;\n*\n* var policies = {\n*     'output': 'real_and_generic',\n*     'casting': 'none'\n* };\n* var abs = factory( dispatcher, [ idt ], odt, policies );\n*\n* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );\n* // returns <ndarray>\n*\n* var y = abs( x );\n* // returns <ndarray>\n*\n* var arr = ndarray2array( y );\n* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]\n*/\nfunction factory( fcn, idtypes, odtypes, policies ) {\n\tvar POLICIES;\n\tvar dt;\n\tvar i;\n\tif ( !isFunction( fcn ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', fcn ) );\n\t}\n\tif ( !isCollection( idtypes ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Second argument must be an array-like object. Value: `%s`.', idtypes ) );\n\t}\n\tfor ( i = 0; i < idtypes.length; i++ ) {\n\t\tdt = idtypes[ i ];\n\t\tif (\n\t\t\t!isCollection( dt ) ||\n\t\t\tdt.length < 1 ||\n\t\t\t!everyBy( dt, isDataType )\n\t\t) {\n\t\t\tthrow new TypeError( format( 'invalid argument. Second argument must contain arrays of data types. Value: `%s`.', idtypes ) );\n\t\t}\n\t}\n\tif (\n\t\t!isCollection( odtypes ) ||\n\t\todtypes.length < 1 ||\n\t\t!everyBy( odtypes, isDataType )\n\t) {\n\t\tthrow new TypeError( format( 'invalid argument. Third argument must be an array of data types. Value: `%s`.', odtypes ) );\n\t}\n\tif ( !isObject( policies ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Fourth argument must be an object. Value: `%s`.', policies ) );\n\t}\n\tif ( !isOutputDataTypePolicy( policies.output ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported output data type policy. Value: `%s`.', policies.output ) );\n\t}\n\tif ( !isInputCastingPolicy( policies.casting ) ) {\n\t\tthrow new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported casting policy. Value: `%s`.', policies.casting ) );\n\t}\n\tPOLICIES = {\n\t\t'output': policies.output,\n\t\t'casting': policies.casting\n\t};\n\tsetReadOnly( unary, 'assign', assign );\n\treturn unary;\n\n\t/**\n\t* Performs element-wise computation.\n\t*\n\t* @private\n\t* @param {ndarray} x - input array\n\t* @param {Options} [options] - options\n\t* @param {*} [options.dtype] - output array data type\n\t* @param {string} [options.order] - output array order\n\t* @throws {TypeError} first argument must be an ndarray\n\t* @throws {TypeError} first argument must have a supported data type\n\t* @throws {TypeError} options argument must be an object\n\t* @throws {TypeError} must provide valid options\n\t* @returns {ndarray} output array\n\t*/\n\tfunction unary( x ) {\n\t\tvar opts;\n\t\tvar err;\n\t\tvar xsh;\n\t\tvar ord;\n\t\tvar xdt;\n\t\tvar ydt;\n\t\tvar tmp;\n\t\tvar dt;\n\t\tvar y;\n\n\t\tif ( !isndarrayLike( x ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );\n\t\t}\n\t\txdt = getDType( x );\n\t\tif ( !contains( idtypes[ 0 ], xdt ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must have one of the following data types: \"%s\". Data type: `%s`.', join( idtypes[ 0 ], '\", \"' ), xdt ) );\n\t\t}\n\t\topts = {};\n\t\tif ( arguments.length > 1 ) {\n\t\t\terr = validate( opts, odtypes, arguments[ 1 ] );\n\t\t\tif ( err ) {\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\t\txsh = getShape( x );\n\t\tord = getOrder( x );\n\n\t\t// Initialize an output array:\n\t\tydt = opts.dtype || unaryOutputDataType( xdt, POLICIES.output );\n\t\ty = empty( xsh, {\n\t\t\t'dtype': ydt,\n\t\t\t'order': opts.order || ord\n\t\t});\n\n\t\t// Determine whether we need to cast the input ndarray...\n\t\tdt = unaryInputCastingDataType( xdt, ydt, POLICIES.casting );\n\t\tif ( xdt !== dt ) {\n\t\t\t// TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility\n\t\t\ttmp = baseEmpty( dt, xsh, ord );\n\t\t\tbaseAssign( [ x, tmp ] );\n\t\t\tx = tmp;\n\t\t}\n\t\tfcn( x, y );\n\t\treturn y;\n\t}\n\n\t/**\n\t* Performs element-wise computation and assigns results to a provided output ndarray.\n\t*\n\t* @private\n\t* @param {ndarray} x - input array\n\t* @param {ndarray} y - output array\n\t* @throws {TypeError} first argument must be an ndarray\n\t* @throws {TypeError} first argument must have a supported data type\n\t* @throws {TypeError} second argument must be an ndarray\n\t* @throws {Error} unable to broadcast the input array against the output array\n\t* @returns {ndarray} output array\n\t*/\n\tfunction assign( x, y ) {\n\t\tvar xdt;\n\t\tvar tmp;\n\t\tvar dt;\n\n\t\tif ( !isndarrayLike( x ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );\n\t\t}\n\t\tif ( !isndarrayLike( y ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. Second argument must be an ndarray. Value: `%s`.', y ) );\n\t\t}\n\t\t// Validate the input ndarray data type in order to maintain similar behavior to above...\n\t\txdt = getDType( x );\n\t\tif ( !contains( idtypes[ 0 ], xdt ) ) {\n\t\t\tthrow new TypeError( format( 'invalid argument. First argument must have one of the following data types: \"%s\". Data type: `%s`.', join( idtypes[ 0 ], '\", \"' ), xdt ) );\n\t\t}\n\t\t// Determine whether we need to cast the input ndarray...\n\t\tdt = unaryInputCastingDataType( xdt, getDType( y ), POLICIES.casting );\n\t\tif ( xdt !== dt ) {\n\t\t\t// TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility\n\t\t\ttmp = baseEmpty( dt, getShape( x ), getOrder( x ) );\n\t\t\tbaseAssign( [ x, tmp ] );\n\t\t\tx = tmp;\n\t\t}\n\t\tfcn( maybeBroadcastArray( x, getShape( y ) ), y );\n\t\treturn y;\n\t}\n}\n\n\n// EXPORTS //\n\nmodule.exports = factory;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2021 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Return a function which performs element-wise computation by applying a unary function to each element in an input ndarray.\n*\n* @module @stdlib/math-tools-unary\n*\n* @example\n* var base = require( '@stdlib/math-base-special-abs' );\n* var dispatch = require( '@stdlib/ndarray-dispatch' );\n* var unary = require( '@stdlib/ndarray-base-unary' );\n* var ndarray2array = require( '@stdlib/ndarray-to-array' );\n* var array = require( '@stdlib/ndarray-array' );\n* var factory = require( '@stdlib/math-tools-unary' );\n*\n* var types = [\n*     'float64', 'float64',\n*     'float32', 'float32',\n*     'generic', 'generic'\n* ];\n* var data = [\n*     base,\n*     base,\n*     base\n* ];\n* var dispatcher = dispatch( unary, types, data, 2, 1, 1 );\n*\n* var idt = [ 'float64', 'float32', 'generic' ];\n* var odt = idt;\n*\n* var policies = {\n*     'output': 'real_and_generic',\n*     'casting': 'none'\n* };\n* var abs = factory( dispatcher, [ idt ], odt, policies );\n*\n* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );\n* // returns <ndarray>\n*\n* var y = abs( x );\n* // returns <ndarray>\n*\n* var arr = ndarray2array( y );\n* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]\n*/\n\n// MAIN //\n\nvar main = require( './main.js' );\n\n\n// EXPORTS //\n\nmodule.exports = main;\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,GAAAC,EAAA,cAsBA,IAAIC,EAAgB,QAAS,gCAAiC,EAC1DC,EAAa,QAAS,iCAAkC,EACxDC,EAAU,QAAS,sCAAuC,EAC1DC,EAAW,QAAS,oCAAqC,EACzDC,EAAS,QAAS,wBAAyB,EAC3CC,EAAO,QAAS,yBAA0B,EAC1CC,EAAS,QAAS,uBAAwB,EA4B9C,SAASC,EAAUC,EAAMC,EAAQC,EAAU,CAC1C,OAAMV,EAAeU,CAAQ,EAGxBT,EAAYS,EAAS,OAAQ,IACjCF,EAAK,MAAQE,EAAQ,MAChB,CAACP,EAAUM,EAAQ,OAAQD,EAAK,KAAM,CAAE,GACrC,IAAI,UAAWF,EAAQ,gFAAiF,QAASD,EAAMI,EAAQ,MAAO,EAAGD,EAAK,KAAM,CAAE,EAG1JP,EAAYS,EAAS,OAAQ,IACjCF,EAAK,MAAQE,EAAQ,MAChB,CAACR,EAASM,EAAK,KAAM,GAClB,IAAI,UAAWF,EAAQ,gFAAiF,QAASD,EAAMD,EAAO,EAAG,MAAO,EAAGI,EAAK,KAAM,CAAE,EAG1J,KAdC,IAAI,UAAWF,EAAQ,qEAAsEI,CAAQ,CAAE,CAehH,CAKAX,EAAO,QAAUQ,IC9EjB,IAAAI,EAAAC,EAAA,SAAAC,GAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAgB,QAAS,gCAAiC,EAC1DC,EAAa,QAAS,4BAA6B,EACnDC,EAAW,QAAS,0BAA2B,EAC/CC,EAAe,QAAS,8BAA+B,EACvDC,EAAyB,QAAS,wDAAyD,EAC3FC,EAAuB,QAAS,qDAAsD,EACtFC,EAAa,QAAS,0CAA2C,EACjEC,EAAW,QAAS,oCAAqC,EACzDC,EAAsB,QAAS,yCAA0C,EACzEC,EAA4B,QAAS,gDAAiD,EACtFC,EAAa,QAAS,6BAA8B,EACpDC,EAAY,QAAS,4BAA6B,EAClDC,EAAsB,QAAS,uCAAwC,EACvEC,EAAW,QAAS,uBAAwB,EAC5CC,EAAW,QAAS,uBAAwB,EAC5CC,EAAW,QAAS,uBAAwB,EAC5CC,EAAQ,QAAS,uBAAwB,EACzCC,EAAU,QAAS,6BAA8B,EACjDC,EAAO,QAAS,yBAA0B,EAC1CC,EAAS,QAAS,uBAAwB,EAC1CC,EAAW,IAyDf,SAASC,GAASC,EAAKC,EAASC,EAASC,EAAW,CACnD,IAAIC,EACAC,EACAC,EACJ,GAAK,CAAC3B,EAAYqB,CAAI,EACrB,MAAM,IAAI,UAAWH,EAAQ,oEAAqEG,CAAI,CAAE,EAEzG,GAAK,CAACnB,EAAcoB,CAAQ,EAC3B,MAAM,IAAI,UAAWJ,EAAQ,+EAAgFI,CAAQ,CAAE,EAExH,IAAMK,EAAI,EAAGA,EAAIL,EAAQ,OAAQK,IAEhC,GADAD,EAAKJ,EAASK,CAAE,EAEf,CAACzB,EAAcwB,CAAG,GAClBA,EAAG,OAAS,GACZ,CAACV,EAASU,EAAIrB,CAAW,EAEzB,MAAM,IAAI,UAAWa,EAAQ,oFAAqFI,CAAQ,CAAE,EAG9H,GACC,CAACpB,EAAcqB,CAAQ,GACvBA,EAAQ,OAAS,GACjB,CAACP,EAASO,EAASlB,CAAW,EAE9B,MAAM,IAAI,UAAWa,EAAQ,gFAAiFK,CAAQ,CAAE,EAEzH,GAAK,CAACtB,EAAUuB,CAAS,EACxB,MAAM,IAAI,UAAWN,EAAQ,oEAAqEM,CAAS,CAAE,EAE9G,GAAK,CAACrB,EAAwBqB,EAAS,MAAO,EAC7C,MAAM,IAAI,UAAWN,EAAQ,+GAAgHM,EAAS,MAAO,CAAE,EAEhK,GAAK,CAACpB,EAAsBoB,EAAS,OAAQ,EAC5C,MAAM,IAAI,UAAWN,EAAQ,sGAAuGM,EAAS,OAAQ,CAAE,EAExJ,OAAAC,EAAW,CACV,OAAUD,EAAS,OACnB,QAAWA,EAAS,OACrB,EACA1B,EAAa8B,EAAO,SAAUC,CAAO,EAC9BD,EAgBP,SAASA,EAAOE,EAAI,CACnB,IAAIC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAX,EACAY,EAEJ,GAAK,CAACvC,EAAe+B,CAAE,EACtB,MAAM,IAAI,UAAWZ,EAAQ,oEAAqEY,CAAE,CAAE,EAGvG,GADAK,EAAMrB,EAAUgB,CAAE,EACb,CAACxB,EAAUgB,EAAS,CAAE,EAAGa,CAAI,EACjC,MAAM,IAAI,UAAWjB,EAAQ,qGAAsGD,EAAMK,EAAS,CAAE,EAAG,MAAO,EAAGa,CAAI,CAAE,EAGxK,GADAJ,EAAO,CAAC,EACH,UAAU,OAAS,IACvBC,EAAMb,EAAUY,EAAMR,EAAS,UAAW,CAAE,CAAE,EACzCS,GACJ,MAAMA,EAGR,OAAAC,EAAMrB,EAAUkB,CAAE,EAClBI,EAAMrB,EAAUiB,CAAE,EAGlBM,EAAML,EAAK,OAASxB,EAAqB4B,EAAKV,EAAS,MAAO,EAC9Da,EAAIvB,EAAOkB,EAAK,CACf,MAASG,EACT,MAASL,EAAK,OAASG,CACxB,CAAC,EAGDR,EAAKlB,EAA2B2B,EAAKC,EAAKX,EAAS,OAAQ,EACtDU,IAAQT,IAEZW,EAAM3B,EAAWgB,EAAIO,EAAKC,CAAI,EAC9BzB,EAAY,CAAEqB,EAAGO,CAAI,CAAE,EACvBP,EAAIO,GAELhB,EAAKS,EAAGQ,CAAE,EACHA,CACR,CAcA,SAAST,EAAQC,EAAGQ,EAAI,CACvB,IAAIH,EACAE,EACAX,EAEJ,GAAK,CAAC3B,EAAe+B,CAAE,EACtB,MAAM,IAAI,UAAWZ,EAAQ,oEAAqEY,CAAE,CAAE,EAEvG,GAAK,CAAC/B,EAAeuC,CAAE,EACtB,MAAM,IAAI,UAAWpB,EAAQ,qEAAsEoB,CAAE,CAAE,EAIxG,GADAH,EAAMrB,EAAUgB,CAAE,EACb,CAACxB,EAAUgB,EAAS,CAAE,EAAGa,CAAI,EACjC,MAAM,IAAI,UAAWjB,EAAQ,qGAAsGD,EAAMK,EAAS,CAAE,EAAG,MAAO,EAAGa,CAAI,CAAE,EAGxK,OAAAT,EAAKlB,EAA2B2B,EAAKrB,EAAUwB,CAAE,EAAGb,EAAS,OAAQ,EAChEU,IAAQT,IAEZW,EAAM3B,EAAWgB,EAAId,EAAUkB,CAAE,EAAGjB,EAAUiB,CAAE,CAAE,EAClDrB,EAAY,CAAEqB,EAAGO,CAAI,CAAE,EACvBP,EAAIO,GAELhB,EAAKV,EAAqBmB,EAAGlB,EAAU0B,CAAE,CAAE,EAAGA,CAAE,EACzCA,CACR,CACD,CAKAzC,EAAO,QAAUuB,KCtLjB,IAAImB,GAAO,IAKX,OAAO,QAAUA",
+  "names": ["require_validate", "__commonJSMin", "exports", "module", "isPlainObject", "hasOwnProp", "isOrder", "contains", "orders", "join", "format", "validate", "opts", "dtypes", "options", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "isndarrayLike", "isFunction", "isObject", "isCollection", "isOutputDataTypePolicy", "isInputCastingPolicy", "isDataType", "contains", "unaryOutputDataType", "unaryInputCastingDataType", "baseAssign", "baseEmpty", "maybeBroadcastArray", "getShape", "getOrder", "getDType", "empty", "everyBy", "join", "format", "validate", "factory", "fcn", "idtypes", "odtypes", "policies", "POLICIES", "dt", "i", "unary", "assign", "x", "opts", "err", "xsh", "ord", "xdt", "ydt", "tmp", "y", "main"]
 }

package/docs/types/index.d.ts

@@ -21,213 +21,127 @@
 /// <reference types="@stdlib/types"/>
 
 import { ArrayLike } from '@stdlib/types/array';
-import { ndarray } from '@stdlib/types/ndarray';
-
-/**
-* Function which operates on a number.
-*
-* @param x - input value
-* @returns return value
+import { OutputPolicy, InputCastingPolicy, DataType, Order, typedndarray } from '@stdlib/types/ndarray';/**
+* Input array.
 */
-type ScalarFunction = ( x: number ) => number; // FIXME: add complex number support
+type InputArray<T> = typedndarray<T>;
 
 /**
-* Function which operates on each element in a strided input array `x` and assigns the results to elements in a strided output array `y`.
-*
-* @param N - number of indexed elements
-* @param x - input array
-* @param strideX - `x` stride length
-* @param y - destination array
-* @param strideY - `y` stride length
-* @returns `y` or `undefined`
+* Output array.
 */
-type StridedArrayFunction = ( N: number, x: ArrayLike<number>, strideX: number, y: ArrayLike<number>, strideY: number ) => ArrayLike<number> | void;
+type OutputArray<U> = typedndarray<U>;
 
 /**
-* Function which operates on each element in a strided input array `x` and assigns the results to elements in a strided output array `y` using alternative (i.e., ndarray) indexing semantics.
-*
-* @param N - number of indexed elements
-* @param x - input array
-* @param strideX - `x` stride length
-* @param offsetX - starting index for `x`
-* @param y - destination array
-* @param strideY - `y` stride length
-* @param offsetY - starting index for `y`
-* @returns `y` or `undefined`
+* Interface defining options.
 */
-type StridedArrayFunctionWithOffsets = ( N: number, x: ArrayLike<number>, strideX: number, offsetX: number, y: ArrayLike<number>, strideY: number, offsetY: number ) => ArrayLike<number> | void;
+interface Options {
+	/**
+	* Output array data type.
+	*/
+	dtype?: DataType;
 
-/**
-* Interface describing a resolution table object.
-*/
-interface Table {
 	/**
-	* Strided look-up table for scalar arguments.
-	*
-	* ## Notes
-	*
-	* -   The strided look-up table should be comprised as follows:
-	*
-	*     ```text
-	*     [ <dtype>, <fcn>, <dtype>, <fcn>, ... ]
-	*     ```
+	* Output array order.
 	*/
-	scalar?: ArrayLike<string | ScalarFunction>;
+	order?: Order;
+}
 
+/**
+* Dispatch policies.
+*/
+interface Policies {
 	/**
-	* Strided look-up table for array-like object arguments.
-	*
-	* ## Notes
-	*
-	* -   The strided look-up table should be comprised as follows:
-	*
-	*     ```text
-	*     [ <dtype>, <fcn>, <dtype>, <fcn>, ... ]
-	*     ```
+	* Output data type policy.
 	*/
-	array?: ArrayLike<string | StridedArrayFunction>;
+	output: OutputPolicy;
 
 	/**
-	* Strided look-up table for ndarray arguments.
-	*
-	* ## Notes
-	*
-	* -   The strided look-up table should be comprised as follows:
-	*
-	*     ```text
-	*     [ <dtype>, <fcn>, <dtype>, <fcn>, ... ]
-	*     ```
+	* Input ndarray casting policy.
 	*/
-	ndarray?: ArrayLike<string | StridedArrayFunctionWithOffsets>;
+	casting: InputCastingPolicy;
 }
 
 /**
-* Interface describing a function which dispatches to a specific function based on input argument types.
+* Unary function.
+*
+* @param x - input ndarray
+* @param y - output ndarray
+* @returns result
 */
-interface DispatchFunction {
-	/**
-	* Dispatches to a function which operates on a number.
-	*
-	* @param x - input value
-	* @returns return value
-	*
-	* @example
-	* var nabs = require( '@stdlib/math-base-special-abs' );
-	*
-	* var table = {
-	*     'scalar': [
-	*         'number', nabs
-	*     ]
-	* };
-	*
-	* var abs = dispatch( table );
-	*
-	* var y = abs( -1.0 );
-	* // returns 1.0
-	*/
-	( x: number ): number;
+type UnaryFunction<T = unknown, U = unknown> = ( x: InputArray<T>, y: OutputArray<U> ) => OutputArray<U> | void;
 
+/**
+* Interface for performing element-wise computation.
+*/
+interface Unary {
 	/**
-	* Dispatches to a function which operates on an ndarray.
-	*
-	* @param x - input value
-	* @returns return value
-	*
-	* @example
-	* var dabs = require( '@stdlib/math-strided-special-dabs' );
-	* var sabs = require( '@stdlib/math-strided-special-sabs' );
-	* var gabs = require( '@stdlib/math-strided-special-abs' );
-	* var array = require( '@stdlib/ndarray-array' );
+	* Performs element-wise computation.
 	*
-	* var table = {
-	*     'ndarray': [
-	*         'float64', dabs.ndarray,
-	*         'float32', sabs.ndarray,
-	*         'generic', gabs.ndarray
-	*     ]
-	* };
-	*
-	* var abs = dispatch( table );
-	*
-	* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
-	* var y = abs( x );
-	* // returns <ndarray>
-	*
-	* var v = y.get( 0, 1 );
-	* // returns 2.0
+	* @param x - input array
+	* @param options - options
+	* @returns output array
 	*/
-	( x: ndarray ): ndarray;
+	<T = unknown, U = unknown>( x: InputArray<T>, options?: Options ): OutputArray<U>; // NOTE: we lose type specificity here, but retaining specificity would likely be difficult and/or tedious to completely enumerate, as the output ndarray data type is dependent on how `x` interacts with output data type policy and whether that policy has been overridden by `options.dtype`. In principle, as well, based on the policy, it is possible to know more exactly which `InputArray` types are actually allowed.
 
 	/**
-	* Dispatches to a function which operates on an array-like object.
-	*
-	* @param x - input value
-	* @returns return value
-	*
-	* @example
-	* var dabs = require( '@stdlib/math-strided-special-dabs' );
-	* var sabs = require( '@stdlib/math-strided-special-sabs' );
-	* var gabs = require( '@stdlib/math-strided-special-abs' );
-	* var Float64Array = require( '@stdlib/array-float64' );
+	* Performs element-wise computation and assigns results to a provided output ndarray.
 	*
-	* var table = {
-	*     'array': [
-	*         'float64', dabs,
-	*         'float32', sabs,
-	*         'generic', gabs
-	*     ]
-	* };
-	*
-	* var abs = dispatch( table );
-	*
-	* var x = new Float64Array( [ -1.0, -2.0 ] );
-	* var y = abs( x );
-	* // returns <Float64Array>[ 1.0, 2.0 ]
+	* @param x - input array
+	* @param y - output array
+	* @returns output array
 	*/
-	( x: ArrayLike<number> ): ArrayLike<number>;
+	assign<T = unknown, U = unknown, V extends OutputArray<U> = OutputArray<U>>( x: InputArray<T>, y: V ): V;
 }
 
 /**
-* Returns a function which dispatches to specified functions based on input argument types.
+* Returns a function which performs element-wise computation.
 *
-* @param table - resolution table object
-* @throws must provide valid table fields
-* @throws table field values must be array-like objects having an even number of elements
-* @throws table field values must consist of dtype-function pairs
-* @returns dispatch function
+* @param fcn - function applies a unary function to each element in an ndarray
+* @param idtypes - list containing lists of supported input data types for each ndarray argument
+* @param odtypes - list of supported output data types
+* @param policies - dispatch policies
+* @returns function which performs element-wise computation
 *
 * @example
-* var nabs = require( '@stdlib/math-base-special-abs' );
-* var dabs = require( '@stdlib/math-strided-special-dabs' );
-* var sabs = require( '@stdlib/math-strided-special-sabs' );
-* var gabs = require( '@stdlib/math-strided-special-abs' );
-* var Float64Array = require( '@stdlib/array-float64' );
+* var base = require( '@stdlib/math-base-special-abs' );
+* var dispatch = require( '@stdlib/ndarray-dispatch' );
+* var unary = require( '@stdlib/ndarray-base-unary' );
+* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+* var array = require( '@stdlib/ndarray-array' );
+*
+* var types = [
+*     'float64', 'float64',
+*     'float32', 'float32',
+*     'generic', 'generic'
+* ];
+* var data = [
+*     base,
+*     base,
+*     base
+* ];
+* var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
 *
-* var table = {
-*     'scalar': [
-*         'number', nabs
-*     ],
-*     'array': [
-*         'float64', dabs,
-*         'float32', sabs,
-*         'generic', gabs
-*     ],
-*     'ndarray': [
-*         'float64', dabs.ndarray,
-*         'float32', sabs.ndarray,
-*         'generic', gabs.ndarray
-*     ]
+* var idt = [ 'float64', 'float32', 'generic' ];
+* var odt = idt;
+*
+* var policies = {
+*     'output': 'real_and_generic',
+*     'casting': 'none'
 * };
+* var abs = factory( dispatcher, [ idt ], odt, policies );
 *
-* var abs = dispatch( table );
+* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
+* // returns <ndarray>
 *
-* var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
 * var y = abs( x );
-* // returns <Float64Array>[ 1.0, 2.0, 3.0 ]
+* // returns <ndarray>
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
 */
-declare function dispatch( table: Table ): DispatchFunction;
+declare function factory<T = unknown, U = unknown>( fcn: UnaryFunction<T, U>, idtypes: ArrayLike<ArrayLike<DataType>>, odtypes: ArrayLike<DataType>, policies: Policies ): Unary;
 
 
 // EXPORTS //
 
-export = dispatch;
+export = factory;

package/lib/index.js

@@ -19,17 +19,17 @@
 'use strict';
 
 /**
-* Return a function which dispatches to specified functions based on input argument types.
+* Return a function which performs element-wise computation by applying a unary function to each element in an input ndarray.
 *
 * @module @stdlib/math-tools-unary
 *
 * @example
 * var base = require( '@stdlib/math-base-special-abs' );
-* var strided = require( '@stdlib/math-strided-special-abs' );
-* var dispatcher = require( '@stdlib/ndarray-dispatch' );
+* var dispatch = require( '@stdlib/ndarray-dispatch' );
 * var unary = require( '@stdlib/ndarray-base-unary' );
-* var Float64Array = require( '@stdlib/array-float64' );
-* var dispatch = require( '@stdlib/math-tools-unary' );
+* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+* var array = require( '@stdlib/ndarray-array' );
+* var factory = require( '@stdlib/math-tools-unary' );
 *
 * var types = [
 *     'float64', 'float64',
@@ -41,20 +41,25 @@
 *     base,
 *     base
 * ];
-* var nd = dispatcher( unary, types, data, 2, 1, 1 );
+* var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
 *
-* var table = {
-*     'number': base,
-*     'complex': null,
-*     'array': strided,
-*     'ndarray': nd
+* var idt = [ 'float64', 'float32', 'generic' ];
+* var odt = idt;
+*
+* var policies = {
+*     'output': 'real_and_generic',
+*     'casting': 'none'
 * };
+* var abs = factory( dispatcher, [ idt ], odt, policies );
 *
-* var abs = dispatch( table );
+* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
+* // returns <ndarray>
 *
-* var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
 * var y = abs( x );
-* // returns <Float64Array>[ 1.0, 2.0, 3.0 ]
+* // returns <ndarray>
+*
+* var arr = ndarray2array( y );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
 */
 
 // MAIN //