@stdlib/math-tools-unary 0.2.2 → 0.3.0

package/lib/main.js

@@ -21,47 +21,52 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
-var isNumber = require( '@stdlib/assert-is-number' ).isPrimitive;
-var isComplexLike = require( '@stdlib/assert-is-complex-like' );
 var isndarrayLike = require( '@stdlib/assert-is-ndarray-like' );
+var isFunction = require( '@stdlib/assert-is-function' );
+var isObject = require( '@stdlib/assert-is-object' );
 var isCollection = require( '@stdlib/assert-is-collection' );
-var dtype = require( '@stdlib/ndarray-base-buffer-dtype' );
-var buffer = require( '@stdlib/ndarray-base-buffer' );
-var broadcast = require( '@stdlib/ndarray-base-broadcast-array' );
+var isOutputDataTypePolicy = require( '@stdlib/ndarray-base-assert-is-output-data-type-policy' );
+var isInputCastingPolicy = require( '@stdlib/ndarray-base-assert-is-input-casting-policy' );
+var isDataType = require( '@stdlib/ndarray-base-assert-is-data-type' );
+var contains = require( '@stdlib/array-base-assert-contains' );
+var unaryOutputDataType = require( '@stdlib/ndarray-base-unary-output-dtype' );
+var unaryInputCastingDataType = require( '@stdlib/ndarray-base-unary-input-casting-dtype' );
+var baseAssign = require( '@stdlib/ndarray-base-assign' );
+var baseEmpty = require( '@stdlib/ndarray-base-empty' );
+var maybeBroadcastArray = require( '@stdlib/ndarray-maybe-broadcast-array' );
+var getShape = require( '@stdlib/ndarray-shape' );
+var getOrder = require( '@stdlib/ndarray-order' );
+var getDType = require( '@stdlib/ndarray-dtype' );
+var empty = require( '@stdlib/ndarray-empty' );
+var everyBy = require( '@stdlib/array-base-every-by' );
+var join = require( '@stdlib/array-base-join' );
 var format = require( '@stdlib/string-format' );
-var ndarrayfcn = require( './ndarray.js' );
-var odtype = require( './resolve_output_dtype.js' );
-var defaults = require( './defaults.json' );
-var validateTable = require( './validate_table.js' );
-var validateOptions = require( './validate_options.js' );
 var validate = require( './validate.js' );
 
 
 // MAIN //
 
 /**
-* Returns a function which dispatches to specified functions based on input argument types.
+* Returns a function which performs element-wise computation.
 *
-* @param {Object} table - resolution table object
-* @param {(Function|null)} [table.number] - function to invoke upon receiving a number
-* @param {(Function|null)} [table.complex] - function to invoke upon receiving a complex number
-* @param {(Function|null)} [table.array] - function to invoke upon receiving an array-like object
-* @param {(Function|null)} [table.ndarray] - function to invoke upon receiving an ndarray-like object
-* @param {Options} [options] - options
-* @param {string} [options.output_dtype_policy='floating-point'] - policy for determining the output array data type
-* @throws {TypeError} first argument must be an object
-* @throws {TypeError} first argument must have valid table fields
-* @throws {Error} each table field value must be either a function or `null`
-* @throws {TypeError} options argument must be an object
-* @throws {TypeError} must provide valid options
-* @returns {Function} dispatch function
+* @param {Function} fcn - function which applies a unary function to each element in an ndarray
+* @param {ArrayLikeObject<StringArray>} idtypes - list containing lists of supported input data types for each ndarray argument
+* @param {StringArray} odtypes - list of supported output data types
+* @param {Object} policies - dispatch policies
+* @param {string} policies.output - output data type policy
+* @param {string} policies.casting - input ndarray casting policy
+* @throws {TypeError} first argument must be a function
+* @throws {TypeError} second argument must be an array containing arrays of supported data types
+* @throws {TypeError} third argument must be an array of supported data types
+* @throws {TypeError} fourth argument must be an object having supported policies
+* @returns {Function} function which performs element-wise computation
 *
 * @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 ndarray2array = require( '@stdlib/ndarray-to-array' );
+* var array = require( '@stdlib/ndarray-array' );
 *
 * var types = [
 *     'float64', 'float64',
@@ -73,173 +78,172 @@ var validate = require( './validate.js' );
 *     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 abs = dispatch( table, {
-*     'output_dtype_policy': 'same'
-* });
+* var policies = {
+*     'output': 'real_and_generic',
+*     'casting': 'none'
+* };
+* var abs = factory( dispatcher, [ idt ], odt, policies );
 *
-* var x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
+* var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
+* // returns <ndarray>
 *
 * 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 ] ]
 */
-function dispatch( table, options ) {
-	var OPTS;
-	var err;
-	var fcn;
-	var t;
-
-	t = {
-		'number': null,
-		'complex': null,
-		'array': null,
-		'ndarray': null
-	};
-	err = validateTable( t, table );
-	if ( err ) {
-		throw err;
+function factory( fcn, idtypes, odtypes, policies ) {
+	var POLICIES;
+	var dt;
+	var i;
+	if ( !isFunction( fcn ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', fcn ) );
 	}
-	OPTS = {
-		'policy': defaults.output_dtype_policy
-	};
-	if ( arguments.length > 1 ) {
-		err = validateOptions( OPTS, options );
-		if ( err ) {
-			throw err;
+	if ( !isCollection( idtypes ) ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be an array-like object. Value: `%s`.', idtypes ) );
+	}
+	for ( i = 0; i < idtypes.length; i++ ) {
+		dt = idtypes[ i ];
+		if (
+			!isCollection( dt ) ||
+			dt.length < 1 ||
+			!everyBy( dt, isDataType )
+		) {
+			throw new TypeError( format( 'invalid argument. Second argument must contain arrays of data types. Value: `%s`.', idtypes ) );
 		}
 	}
-	fcn = dispatcher;
-	setReadOnly( fcn, 'assign', assign );
-	return fcn;
+	if (
+		!isCollection( odtypes ) ||
+		odtypes.length < 1 ||
+		!everyBy( odtypes, isDataType )
+	) {
+		throw new TypeError( format( 'invalid argument. Third argument must be an array of data types. Value: `%s`.', odtypes ) );
+	}
+	if ( !isObject( policies ) ) {
+		throw new TypeError( format( 'invalid argument. Fourth argument must be an object. Value: `%s`.', policies ) );
+	}
+	if ( !isOutputDataTypePolicy( policies.output ) ) {
+		throw new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported output data type policy. Value: `%s`.', policies.output ) );
+	}
+	if ( !isInputCastingPolicy( policies.casting ) ) {
+		throw new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported casting policy. Value: `%s`.', policies.casting ) );
+	}
+	POLICIES = {
+		'output': policies.output,
+		'casting': policies.casting
+	};
+	setReadOnly( unary, 'assign', assign );
+	return unary;
 
 	/**
-	* Function interface which performs dispatch.
+	* Performs element-wise computation.
 	*
 	* @private
-	* @param {(ndarray|Collection|number|Complex)} x - input value
+	* @param {ndarray} x - input array
 	* @param {Options} [options] - options
-	* @param {string} [options.dtype] - output array data type
-	* @param {string} [options.order] - output array order (row-major or column-major)
-	* @throws {TypeError} first argument must be a supported data type
+	* @param {*} [options.dtype] - output array data type
+	* @param {string} [options.order] - output array order
+	* @throws {TypeError} first argument must be an ndarray
+	* @throws {TypeError} first argument must have a supported data type
 	* @throws {TypeError} options argument must be an object
 	* @throws {TypeError} must provide valid options
-	* @returns {(ndarray|Collection|number|Complex)} results
+	* @returns {ndarray} output array
 	*/
-	function dispatcher( x ) {
-		var xdtype;
-		var ydtype;
+	function unary( x ) {
 		var opts;
 		var err;
+		var xsh;
+		var ord;
+		var xdt;
+		var ydt;
+		var tmp;
+		var dt;
 		var y;
-		if ( isNumber( x ) ) {
-			if ( t.number ) {
-				return t.number( x );
-			}
-			throw new TypeError( 'invalid argument. Providing a number is not supported.' );
+
+		if ( !isndarrayLike( x ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
 		}
-		if ( isComplexLike( x ) ) {
-			if ( t.complex ) {
-				return t.complex( x );
-			}
-			throw new TypeError( 'invalid argument. Providing a complex number is not supported.' );
+		xdt = getDType( x );
+		if ( !contains( idtypes[ 0 ], xdt ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( idtypes[ 0 ], '", "' ), xdt ) );
 		}
 		opts = {};
 		if ( arguments.length > 1 ) {
-			err = validate( opts, arguments[ 1 ] );
+			err = validate( opts, odtypes, arguments[ 1 ] );
 			if ( err ) {
 				throw err;
 			}
 		}
-		if ( isndarrayLike( x ) ) {
-			if ( t.ndarray === null ) {
-				throw new TypeError( 'invalid argument. Providing an ndarray is not supported.' );
-			}
-			ydtype = opts.dtype || odtype( x.dtype, OPTS.policy );
-			return ndarrayfcn( t.ndarray, x, ydtype, opts.order || x.order );
-		}
-		if ( isCollection( x ) ) {
-			if ( t.array === null ) {
-				throw new TypeError( 'invalid argument. Providing an array-like object is not supported.' );
-			}
-			xdtype = dtype( x ) || 'generic';
-			ydtype = opts.dtype || odtype( xdtype, OPTS.policy );
-			y = buffer( ydtype, x.length );
-			t.array( x.length, xdtype, x, 1, ydtype, y, 1 );
-			return y;
+		xsh = getShape( x );
+		ord = getOrder( x );
+
+		// Initialize an output array:
+		ydt = opts.dtype || unaryOutputDataType( xdt, POLICIES.output );
+		y = empty( xsh, {
+			'dtype': ydt,
+			'order': opts.order || ord
+		});
+
+		// Determine whether we need to cast the input ndarray...
+		dt = unaryInputCastingDataType( xdt, ydt, POLICIES.casting );
+		if ( xdt !== dt ) {
+			// TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+			tmp = baseEmpty( dt, xsh, ord );
+			baseAssign( [ x, tmp ] );
+			x = tmp;
 		}
-		throw new TypeError( format( 'invalid argument. Must provide an argument having a supported data type. Value: `%s`.', x ) );
+		fcn( x, y );
+		return y;
 	}
 
 	/**
-	* Function interface which performs dispatch and assigns results to a provided output array.
+	* Performs element-wise computation and assigns results to a provided output ndarray.
 	*
 	* @private
-	* @param {(ndarray|Collection)} x - input array
-	* @param {(ndarray|Collection)} y - output array
-	* @throws {TypeError} first argument must be a supported data type
-	* @throws {TypeError} second argument must be a supported data type
-	* @throws {TypeError} first and second argument must be the same "kind" (i.e., either both ndarrays or both collections)
-	* @throws {RangeError} output array must have sufficient elements
+	* @param {ndarray} x - input array
+	* @param {ndarray} y - output array
+	* @throws {TypeError} first argument must be an ndarray
+	* @throws {TypeError} first argument must have a supported data type
+	* @throws {TypeError} second argument must be an ndarray
 	* @throws {Error} unable to broadcast the input array against the output array
-	* @returns {(ndarray|Collection)} output array
+	* @returns {ndarray} output array
 	*/
 	function assign( x, y ) {
-		var xsh;
-		var ysh;
-		var i;
-		if ( isndarrayLike( x ) ) {
-			if ( isndarrayLike( y ) ) {
-				xsh = x.shape;
-				ysh = y.shape;
+		var xdt;
+		var tmp;
+		var dt;
 
-				// Check whether we need to broadcast `x`...
-				if ( xsh.length === ysh.length ) {
-					for ( i = 0; i < xsh.length; i++ ) {
-						// Check whether dimensions match...
-						if ( xsh[ i ] !== ysh[ i ] ) {
-							// We found a mismatched dimension; delegate to `broadcast` to ensure that `x` is broadcast compatible with the output array shape...
-							x = broadcast( x, ysh );
-							break;
-						}
-					}
-				} else {
-					// 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...
-					x = broadcast( x, ysh );
-				}
-				t.ndarray( x, y );
-				return y;
-			}
-			throw new TypeError( 'invalid argument. If the first argument is an ndarray, the second argument must be an ndarray.' );
+		if ( !isndarrayLike( x ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
 		}
-		if ( isCollection( x ) ) {
-			if ( isCollection( y ) ) {
-				if ( y.length !== x.length ) {
-					throw new RangeError( 'invalid argument. Output array must have the same number of elements (i.e., length) as the input array.' );
-				}
-				t.array( x.length, dtype( x ) || 'generic', x, 1, dtype( y ) || 'generic', y, 1 );
-				return y;
-			}
-			throw new TypeError( 'invalid argument. If the first argument is an array-like object, the second argument must be an array-like object.' );
+		if ( !isndarrayLike( y ) ) {
+			throw new TypeError( format( 'invalid argument. Second argument must be an ndarray. Value: `%s`.', y ) );
 		}
-		if ( isNumber( x ) ) {
-			throw new TypeError( 'invalid argument. Providing a number is not supported. Consider providing a zero-dimensional ndarray containing the numeric value.' );
+		// Validate the input ndarray data type in order to maintain similar behavior to above...
+		xdt = getDType( x );
+		if ( !contains( idtypes[ 0 ], xdt ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( idtypes[ 0 ], '", "' ), xdt ) );
 		}
-		if ( isComplexLike( x ) ) {
-			throw new TypeError( 'invalid argument. Providing a complex number is not supported. Consider providing a zero-dimensional ndarray containing the complex number value.' );
+		// Determine whether we need to cast the input ndarray...
+		dt = unaryInputCastingDataType( xdt, getDType( y ), POLICIES.casting );
+		if ( xdt !== dt ) {
+			// TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+			tmp = baseEmpty( dt, getShape( x ), getOrder( x ) );
+			baseAssign( [ x, tmp ] );
+			x = tmp;
 		}
-		throw new TypeError( format( 'invalid argument. Must provide an argument having a supported data type. Value: `%s`.', x ) );
+		fcn( maybeBroadcastArray( x, getShape( y ) ), y );
+		return y;
 	}
 }
 
 
 // EXPORTS //
 
-module.exports = dispatch;
+module.exports = factory;

package/lib/validate.js

@@ -22,18 +22,13 @@
 
 var isPlainObject = require( '@stdlib/assert-is-plain-object' );
 var hasOwnProp = require( '@stdlib/assert-has-own-property' );
-var contains = require( '@stdlib/assert-contains' );
+var isOrder = require( '@stdlib/ndarray-base-assert-is-order' );
+var contains = require( '@stdlib/array-base-assert-contains' );
 var orders = require( '@stdlib/ndarray-orders' );
-var dtypes = require( '@stdlib/ndarray-dtypes' );
+var join = require( '@stdlib/array-base-join' );
 var format = require( '@stdlib/string-format' );
 
 
-// VARIABLES //
-
-var ORDERS = orders();
-var DTYPES = dtypes();
-
-
 // MAIN //
 
 /**
@@ -41,35 +36,38 @@ var DTYPES = dtypes();
 *
 * @private
 * @param {Object} opts - destination object
+* @param {Array} dtypes - list of supported output data types
 * @param {Object} options - options
-* @param {string} [options.dtype] - output array data type
+* @param {*} [options.dtype] - output array data type
 * @param {string} [options.order] - output array order
 * @returns {(Error|null)} null or an error object
 *
 * @example
+* var dtypes = [ 'float64', 'float32', 'generic' ];
+*
 * var opts = {};
 * var options = {
 *     'order': 'row-major'
 * };
-* var err = validate( opts, options );
+* var err = validate( opts, dtypes, options );
 * if ( err ) {
 *     throw err;
 * }
 */
-function validate( opts, options ) {
+function validate( opts, dtypes, options ) {
 	if ( !isPlainObject( options ) ) {
 		return new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
 	}
 	if ( hasOwnProp( options, 'dtype' ) ) {
 		opts.dtype = options.dtype;
-		if ( !contains( DTYPES, opts.dtype ) ) {
-			return new TypeError( format( 'invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.', 'dtype', opts.dtype ) );
+		if ( !contains( dtypes, String( opts.dtype ) ) ) {
+			return new TypeError( format( 'invalid option. `%s` option must be one of the following: "%s". Option: `%s`.', 'dtype', join( dtypes, '", "' ), opts.dtype ) );
 		}
 	}
 	if ( hasOwnProp( options, 'order' ) ) {
 		opts.order = options.order;
-		if ( !contains( ORDERS, opts.order ) ) {
-			return new TypeError( format( 'invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.', 'order', opts.order ) );
+		if ( !isOrder( opts.order ) ) {
+			return new TypeError( format( 'invalid option. `%s` option must be one of the following: "%s". Option: `%s`.', 'order', join( orders(), '", "' ), opts.order ) );
 		}
 	}
 	return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/math-tools-unary",
-  "version": "0.2.2",
-  "description": "Multiple dispatch for unary mathematical functions.",
+  "version": "0.3.0",
+  "description": "Create a function which performs element-wise computation by applying a unary function to each element in an input ndarray.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -30,27 +30,31 @@
     "url": "https://github.com/stdlib-js/stdlib/issues"
   },
   "dependencies": {
-    "@stdlib/array-base-copy-indexed": "^0.2.2",
-    "@stdlib/assert-contains": "^0.2.2",
+    "@stdlib/array-base-assert-contains": "^0.2.2",
+    "@stdlib/array-base-every-by": "^0.2.2",
+    "@stdlib/array-base-join": "^0.1.1",
     "@stdlib/assert-has-own-property": "^0.2.2",
     "@stdlib/assert-is-collection": "^0.2.2",
-    "@stdlib/assert-is-complex-like": "^0.2.2",
     "@stdlib/assert-is-function": "^0.2.2",
     "@stdlib/assert-is-ndarray-like": "^0.2.2",
-    "@stdlib/assert-is-null": "^0.2.2",
-    "@stdlib/assert-is-number": "^0.2.2",
+    "@stdlib/assert-is-object": "^0.2.2",
     "@stdlib/assert-is-plain-object": "^0.2.2",
-    "@stdlib/ndarray-base-broadcast-array": "^0.2.2",
-    "@stdlib/ndarray-base-buffer": "^0.2.1",
-    "@stdlib/ndarray-base-buffer-dtype": "^0.2.1",
-    "@stdlib/ndarray-base-numel": "^0.2.2",
-    "@stdlib/ndarray-base-shape2strides": "^0.2.2",
-    "@stdlib/ndarray-ctor": "^0.2.1",
-    "@stdlib/ndarray-dtypes": "^0.3.0",
+    "@stdlib/ndarray-base-assert-is-data-type": "^0.3.0",
+    "@stdlib/ndarray-base-assert-is-input-casting-policy": "^0.1.0",
+    "@stdlib/ndarray-base-assert-is-order": "^0.2.2",
+    "@stdlib/ndarray-base-assert-is-output-data-type-policy": "^0.1.0",
+    "@stdlib/ndarray-base-assign": "^0.1.1",
+    "@stdlib/ndarray-base-empty": "^0.3.0",
+    "@stdlib/ndarray-base-unary-input-casting-dtype": "^0.1.0",
+    "@stdlib/ndarray-base-unary-output-dtype": "^0.3.0",
+    "@stdlib/ndarray-dtype": "^0.2.2",
+    "@stdlib/ndarray-empty": "^0.3.0",
+    "@stdlib/ndarray-maybe-broadcast-array": "^0.2.2",
+    "@stdlib/ndarray-order": "^0.2.2",
     "@stdlib/ndarray-orders": "^0.2.2",
+    "@stdlib/ndarray-shape": "^0.2.2",
     "@stdlib/string-format": "^0.2.2",
     "@stdlib/utils-define-nonenumerable-read-only-property": "^0.2.2",
-    "@stdlib/utils-keys": "^0.2.2",
     "@stdlib/error-tools-fmtprodmsg": "^0.2.2"
   },
   "devDependencies": {},
@@ -80,9 +84,9 @@
     "dispatch",
     "multimethod",
     "multimethods",
-    "ndarray"
+    "ndarray",
+    "ufunc"
   ],
-  "__stdlib__": {},
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/stdlib"

package/lib/defaults.json

@@ -1,3 +0,0 @@
-{
-	"output_dtype_policy": "floating-point"
-}

package/lib/ndarray.js

@@ -1,63 +0,0 @@
-/**
-* @license Apache-2.0
-*
-* Copyright (c) 2021 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 ndarray = require( '@stdlib/ndarray-ctor' );
-var buffer = require( '@stdlib/ndarray-base-buffer' );
-var shape2strides = require( '@stdlib/ndarray-base-shape2strides' );
-var numel = require( '@stdlib/ndarray-base-numel' );
-var copy = require( '@stdlib/array-base-copy-indexed' );
-
-
-// MAIN //
-
-/**
-* Applies a function to an ndarray.
-*
-* @private
-* @param {Function} fcn - function to apply
-* @param {ndarray} x - input array
-* @param {string} ydtype - output array data type
-* @param {string} yorder - output array order
-* @returns {ndarray} output array
-*/
-function ndarrayfcn( fcn, x, ydtype, yorder ) {
-	var shape;
-	var buf;
-	var y;
-
-	// Check if we were provided a zero-dimensional array...
-	shape = 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)
-	if ( shape.length === 0 ) {
-		buf = buffer( ydtype, 1 );
-		y = ndarray( ydtype, buf, [], [ 0 ], 0, yorder );
-	} else {
-		buf = 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.
-		y = ndarray( ydtype, buf, shape, shape2strides( shape, yorder ), 0, yorder ); // eslint-disable-line max-len
-	}
-	fcn( x, y );
-	return y;
-}
-
-
-// EXPORTS //
-
-module.exports = ndarrayfcn;

package/lib/policies.json

@@ -1,6 +0,0 @@
-[
-	"same",
-	"floating-point",
-  "real floating-point",
-  "complex floating-point"
-]