@stdlib/math-tools-unary 0.2.2 → 0.3.1

package/NOTICE

@@ -1 +1 @@
-Copyright (c) 2016-2024 The Stdlib Authors.
+Copyright (c) 2016-2026 The Stdlib Authors.

package/README.md

@@ -33,12 +33,18 @@ limitations under the License.
 
 [![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] <!-- [![dependencies][dependencies-image]][dependencies-url] -->
 
-> Multiple dispatch for unary mathematical functions.
+> Create a function which performs element-wise computation by applying a unary function to each element in an input ndarray.
 
 <!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
 
 <section class="intro">
 
+The purpose of this package is to provide a thin wrapper around a lower-level interface supporting multiple dispatch based on the data types of provided ndarray arguments. The wrapper performs the following tasks:
+
+-   validates input arguments.
+-   casts input ndarrays according to a casting policy.
+-   allocates an output ndarray according to an output data type policy.
+
 </section>
 
 <!-- /.intro -->
@@ -60,184 +66,210 @@ npm install @stdlib/math-tools-unary
 ## Usage
 
 ```javascript
-var dispatch = require( '@stdlib/math-tools-unary' );
+var factory = require( '@stdlib/math-tools-unary' );
 ```
 
-#### dispatch( table )
+#### factory( fcn, idtypes, odtypes, policies )
 
-Returns a function which dispatches to specified functions based on input argument types.
+Returns a function which performs element-wise computation by applying a unary function to each element in an input ndarray.
 
 <!-- eslint-disable array-element-newline -->
 
 ```javascript
-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 table = {
-    'scalar': [
-        'number', nabs
-    ],
-    'array': [
-        'float64', dabs,
-        'float32', sabs,
-        'generic', gabs
-    ],
-    'ndarray': [
-        'float64', dabs.ndarray,
-        'float32', sabs.ndarray,
-        'generic', gabs.ndarray
-    ]
-};
+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 abs = dispatch( table );
+var types = [
+    'float64', 'float64',
+    'float64', 'generic',
+    'generic', 'generic'
+];
+var data = [
+    base,
+    base,
+    base
+];
+var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
+
+var idt = [ 'float64', 'generic' ];
+var odt = idt;
+
+var policies = {
+    'output': 'real_and_generic',
+    'casting': 'none'
+};
+var ufunc = factory( dispatcher, [ idt ], odt, policies );
 ```
 
-The function accepts the following arguments:
-
--   **table**: resolution table object which maps input argument types to corresponding implementations.
-
-A `table` resolution object may contain one or more of the following fields:
+The function has the following arguments:
 
--   **scalar**: strided look-up table for scalar arguments. Implementation functions must accept a single input argument: a scalar value. Supported data types: `'number'` and `'complex'`.
+-   **fcn**: function which applies a unary function to each element in an ndarray and assigns results to an output ndarray.
 
--   **array**: strided look-up table for array-like object arguments. Implementation functions must follow strided array interface argument conventions:
+-   **idtypes**: list containing lists of supported input data types for each input ndarray argument.
 
-    ```text
-    fcn( N, x, strideX, y, strideY )
-    ```
+-   **odtypes**: list of supported output data types.
 
-    where
+-   **policies**: dispatch policies. Must have the following properties:
 
-    -   **N**: number of indexed elements.
-    -   **x**: input strided array.
-    -   **strideX**: index increment for `x`.
-    -   **y**: destination strided array.
-    -   **strideY**: index increment for `y`.
+    -   **output**: output data type [policy][@stdlib/ndarray/output-dtype-policies].
+    -   **casting**: input ndarray casting [policy][@stdlib/ndarray/input-casting-policies].
 
-    Supported array data types consist of all supported [ndarray][@stdlib/ndarray/dtypes] data types.
+#### ufunc( x\[, options] )
 
--   **ndarray**: strided look-up table for [`ndarray`][@stdlib/ndarray/ctor] arguments. Implementation functions must follow strided array ndarray interface argument conventions:
+Performs element-wise computation.
 
-    ```text
-    fcn( N, x, strideX, offsetX, y, strideY, offsetY )
-    ```
+<!-- eslint-disable array-element-newline -->
 
-    where
+```javascript
+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' );
 
-    -   **N**: number of indexed elements.
-    -   **x**: input strided array (i.e., underlying input [`ndarray`][@stdlib/ndarray/ctor] buffer).
-    -   **strideX**: index increment for `x`.
-    -   **offsetX**: starting index for `x`.
-    -   **y**: destination strided array (i.e., underlying output [`ndarray`][@stdlib/ndarray/ctor] buffer).
-    -   **strideY**: index increment for `y`.
-    -   **offsetY**: starting index for `y`.
+var types = [
+    'float64', 'float64',
+    'float64', 'generic',
+    'generic', 'generic'
+];
+var data = [
+    base,
+    base,
+    base
+];
+var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
+
+var idt = [ 'float64', 'generic' ];
+var odt = idt;
+
+var policies = {
+    'output': 'real_and_generic',
+    'casting': 'none'
+};
+var ufunc = factory( dispatcher, [ idt ], odt, policies );
 
-    Supported data types consist of all supported [ndarray][@stdlib/ndarray/dtypes] data types.
+var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
+// returns <ndarray>
 
-Each strided look-up table should be comprised as follows:
+var y = ufunc( x );
+// returns <ndarray>
 
-```text
-[ <dtype>, <fcn>, <dtype>, <fcn>, ... ]
+var arr = ndarray2array( y );
+// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
 ```
 
-If an argument's data type is **not** found in the argument's corresponding look-up table and if a `'generic'` data type is present in that same table, the returned dispatch function will resolve the "generic" implementation. In other words, an implementation associated with a `'generic'` data type will be treated as the default implementation.
+The function has the following parameters:
 
-If unable to resolve an implementation for a provided argument data type, the returned function throws an error.
+-   **x**: input ndarray.
+-   **options**: function options (_optional_).
 
-* * *
+The function accepts the following options:
 
-#### dispatcher( x )
+-   **dtype**: output ndarray data type. Setting this option, overrides the output data type policy.
+-   **order**: output ndarray order.
 
-Dispatches to an underlying implementation based the data type of `x`.
+By default, the function returns an ndarray having a data type determined by the output data type policy. To override the default behavior, set the `dtype` option.
 
 <!-- eslint-disable array-element-newline -->
 
 ```javascript
-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 table = {
-    'scalar': [
-        'number', nabs
-    ],
-    'array': [
-        'float64', dabs,
-        'float32', sabs,
-        'generic', gabs
-    ],
-    'ndarray': [
-        'float64', dabs.ndarray,
-        'float32', sabs.ndarray,
-        'generic', gabs.ndarray
-    ]
+var base = require( '@stdlib/math-base-special-abs' );
+var dispatch = require( '@stdlib/ndarray-dispatch' );
+var unary = require( '@stdlib/ndarray-base-unary' );
+var getDType = require( '@stdlib/ndarray-dtype' );
+var array = require( '@stdlib/ndarray-array' );
+
+var types = [
+    'float64', 'float64',
+    'float64', 'generic',
+    'generic', 'generic'
+];
+var data = [
+    base,
+    base,
+    base
+];
+var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
+
+var idt = [ 'float64', 'generic' ];
+var odt = idt;
+
+var policies = {
+    'output': 'real_and_generic',
+    'casting': 'none'
 };
+var ufunc = factory( dispatcher, [ idt ], odt, policies );
 
-var abs = dispatch( table );
+var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
+// returns <ndarray>
 
-var y = abs( -1.0 );
-// returns 1.0
-```
+var y = ufunc( x, {
+    'dtype': 'generic'
+});
+// returns <ndarray>
 
-The returned dispatch function accepts the following arguments:
+var dt = getDType( y );
+// returns 'generic'
+```
 
--   **x**: input [`ndarray`][@stdlib/ndarray/ctor], array-like object, or number. If provided an [`ndarray`][@stdlib/ndarray/ctor] or array-like object, the function performs element-wise computation.
+#### ufunc.assign( x, out )
 
-If provided an [`ndarray`][@stdlib/ndarray/ctor], the function returns an [`ndarray`][@stdlib/ndarray/ctor] having the same shape and data type as `x`.
+Performs element-wise computation and assigns results to a provided output ndarray.
 
 <!-- eslint-disable array-element-newline -->
 
 ```javascript
-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 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 zerosLike = require( '@stdlib/ndarray-zeros-like' );
 var array = require( '@stdlib/ndarray-array' );
 
-var table = {
-    'ndarray': [
-        'float64', dabs.ndarray,
-        'float32', sabs.ndarray,
-        'generic', gabs.ndarray
-    ]
+var types = [
+    'float64', 'float64',
+    'float64', 'generic',
+    'generic', 'generic'
+];
+var data = [
+    base,
+    base,
+    base
+];
+var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
+
+var idt = [ 'float64', 'generic' ];
+var odt = idt;
+
+var policies = {
+    'output': 'real_and_generic',
+    'casting': 'none'
 };
+var ufunc = factory( dispatcher, [ idt ], odt, policies );
 
-var abs = dispatch( table );
-
-var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] ); // 2x2
-var y = abs( x );
+var x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
 // returns <ndarray>
 
-var v = y.get( 0, 1 );
-// returns 2.0
-```
+var y = zerosLike( x );
+// returns <ndarray>
 
-If provided an array-like object, the function returns an array-like object having the same length and data type as `x`.
+var out = ufunc.assign( x, y );
+// returns <ndarray>
 
-<!-- eslint-disable array-element-newline -->
+var bool = ( out === y );
+// returns true
 
-```javascript
-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 table = {
-    'array': [
-        'float64', dabs,
-        'float32', sabs,
-        'generic', gabs
-    ]
-};
+var arr = ndarray2array( out );
+// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
+```
 
-var abs = dispatch( table );
+The method has the following parameters:
 
-var x = new Float64Array( [ -1.0, -2.0 ] );
-var y = abs( x );
-// returns <Float64Array>[ 1.0, 2.0 ]
-```
+-   **x**: input ndarray.
+-   **out**: output ndarray.
 
 </section>
 
@@ -247,14 +279,27 @@ var y = abs( x );
 
 <section class="notes">
 
+## Notes
+
+-   A provided unary function should have the following signature:
+
+    ```text
+    f( x, y )
+    ```
+
+    where
+
+    -   **x**: input ndarray.
+    -   **y**: output ndarray.
+
+-   The output data type policy only applies to the function returned by the main function. For the `assign` method, the output ndarray is allowed to have any supported output data type.
+
 </section>
 
 <!-- /.notes -->
 
 <!-- Package usage examples. -->
 
-* * *
-
 <section class="examples">
 
 ## Examples
@@ -264,63 +309,49 @@ var y = abs( x );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-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 array = require( '@stdlib/ndarray-array' );
-var ind2sub = require( '@stdlib/ndarray-ind2sub' );
-var dispatch = require( '@stdlib/math-tools-unary' );
-
-var table;
-var sub;
-var abs;
-var sh;
-var x;
-var y;
-var i;
-
-// Define a table for resolving unary functions based on argument data types:
-table = {
-    'scalar': [
-        'number', nabs
-    ],
-    'array': [
-        'float64', dabs,
-        'float32', sabs,
-        'generic', gabs
-    ],
-    'ndarray': [
-        'float64', dabs.ndarray,
-        'float32', sabs.ndarray,
-        'generic', gabs.ndarray
-    ]
-};
+var base = require( '@stdlib/math-base-special-abs' );
+var basef = require( '@stdlib/math-base-special-absf' );
+var uniform = require( '@stdlib/random-uniform' );
+var dispatch = require( '@stdlib/ndarray-dispatch' );
+var ndarray2array = require( '@stdlib/ndarray-to-array' );
+var unary = require( '@stdlib/ndarray-base-unary' );
+var ufunc = require( '@stdlib/math-tools-unary' );
 
 // Create a function which dispatches based on argument data types:
-abs = dispatch( table );
-
-// Provide a number...
-y = abs( -1.0 );
-console.log( 'x = %d => abs(x) = %d', -1.0, y );
-
-// Provide an array-like object...
-x = new Float64Array( [ -1.0, -2.0, -3.0 ] );
-y = abs( x );
-for ( i = 0; i < x.length; i++ ) {
-    console.log( 'x_%d = %d => abs(x_%d) = %d', i, x[ i ], i, y[ i ] );
-}
-
-// Provide an ndarray...
-x = array( [ [ -1.0, -2.0 ], [ -3.0, -4.0 ] ] );
-sh = x.shape;
-
-y = abs( x );
-for ( i = 0; i < x.length; i++ ) {
-    sub = ind2sub( sh, i );
-    console.log( 'x_%d%d = %d => abs(x_%d%d) = %d', sub[ 0 ], sub[ 1 ], x.iget( i ), sub[ 0 ], sub[ 1 ], y.iget( i ) );
-}
+var types = [
+    'float64', 'float64',
+    'float32', 'float32',
+    'generic', 'generic'
+];
+var data = [
+    base,
+    basef,
+    base
+];
+var dispatcher = dispatch( unary, types, data, 2, 1, 1 );
+
+// Define the supported input and output data types:
+var idt = [ 'float64', 'float32', 'generic' ];
+var odt = [ 'float64', 'float32', 'generic' ];
+
+// Define dispatch policies:
+var policies = {
+    'output': 'same',
+    'casting': 'none'
+};
+
+// Create a function that performs element-wise computation:
+var abs = ufunc( dispatcher, [ idt ], odt, policies );
+
+// Generate an array of random numbers:
+var x = uniform( [ 5, 5 ], -10.0, 10.0, {
+    'dtype': 'float64'
+});
+console.log( ndarray2array( x ) );
+
+// Perform element-wise computation:
+var y = abs( x );
+console.log( ndarray2array( y ) );
 ```
 
 </section>
@@ -369,7 +400,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2026. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -382,8 +413,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/math-tools-unary.svg
 [npm-url]: https://npmjs.org/package/@stdlib/math-tools-unary
 
-[test-image]: https://github.com/stdlib-js/math-tools-unary/actions/workflows/test.yml/badge.svg?branch=v0.2.2
-[test-url]: https://github.com/stdlib-js/math-tools-unary/actions/workflows/test.yml?query=branch:v0.2.2
+[test-image]: https://github.com/stdlib-js/math-tools-unary/actions/workflows/test.yml/badge.svg?branch=v0.3.1
+[test-url]: https://github.com/stdlib-js/math-tools-unary/actions/workflows/test.yml?query=branch:v0.3.1
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/math-tools-unary/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/math-tools-unary?branch=main
@@ -395,8 +426,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 -->
 
-[chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
+[chat-image]: https://img.shields.io/badge/zulip-join_chat-brightgreen.svg
+[chat-url]: https://stdlib.zulipchat.com
 
 [stdlib]: https://github.com/stdlib-js/stdlib
 
@@ -415,9 +446,9 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 [stdlib-license]: https://raw.githubusercontent.com/stdlib-js/math-tools-unary/main/LICENSE
 
-[@stdlib/ndarray/ctor]: https://www.npmjs.com/package/@stdlib/ndarray-ctor
+[@stdlib/ndarray/output-dtype-policies]: https://www.npmjs.com/package/@stdlib/ndarray-output-dtype-policies
 
-[@stdlib/ndarray/dtypes]: https://www.npmjs.com/package/@stdlib/ndarray-dtypes
+[@stdlib/ndarray/input-casting-policies]: https://www.npmjs.com/package/@stdlib/ndarray-input-casting-policies
 
 </section>
 

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 /// <reference path="../docs/types/index.d.ts" />
-import dispatch from '../docs/types/index';
-export = dispatch;
+import factory from '../docs/types/index';
+export = factory;

package/dist/index.js

@@ -1,19 +1,7 @@
-"use strict";var v=function(r,e){return function(){return e||r((e={exports:{}}).exports,e),e.exports}};var b=v(function(Pr,w){"use strict";var h=require("@stdlib/ndarray-ctor"),q=require("@stdlib/ndarray-base-buffer"),B=require("@stdlib/ndarray-base-shape2strides"),G=require("@stdlib/ndarray-base-numel"),H=require("@stdlib/array-base-copy-indexed");function J(r,e,u,n){var t,i,d;return t=H(e.shape),t.length===0?(i=q(u,1),d=h(u,i,[],[0],0,n)):(i=q(u,e.length||G(t)),d=h(u,i,t,B(t,n),0,n)),r(e,d),d}w.exports=J});var T=v(function(jr,E){"use strict";var Q=require("@stdlib/string-format");function W(r,e){switch(e){case"same":return r;case"floating-point":return r==="float64"||r==="float32"||r==="generic"||r==="complex128"||r==="complex64"?r:"float64";case"real floating-point":return r==="float64"||r==="float32"||r==="generic"?r:"float64";case"complex floating-point":return r==="complex128"||r==="complex64"?r:"complex128";default:throw new Error(Q("invalid option. Unsupported policy for determining an output array data type. Option: `%s`.",e))}}E.exports=W});var O=v(function(_r,X){X.exports={output_dtype_policy:"floating-point"}});var _=v(function(kr,j){"use strict";var Z=require("@stdlib/assert-is-plain-object"),$=require("@stdlib/assert-has-own-property"),x=require("@stdlib/assert-is-function"),rr=require("@stdlib/assert-is-null"),er=require("@stdlib/utils-keys"),P=require("@stdlib/string-format");function ar(r,e){var u,n,t,i;if(!Z(e))return new TypeError(P("invalid argument. Resolution table must be an object. Value: `%s`.",e));for(u=er(r),i=0;i<u.length;i++)if(t=u[i],$(e,t)){if(n=e[t],!x(n)&&!rr(n))return new TypeError(P("invalid argument. Resolution table `%s` field value must be either a function or null. Value: `%s`.",t,n));r[t]=n}return null}j.exports=ar});var k=v(function(Rr,ir){ir.exports=["same","floating-point","real floating-point","complex floating-point"]});var z=v(function(Vr,V){"use strict";var nr=require("@stdlib/assert-is-plain-object"),tr=require("@stdlib/assert-has-own-property"),ur=require("@stdlib/assert-contains"),R=require("@stdlib/string-format"),or=k();function lr(r,e){return nr(e)?tr(e,"output_dtype_policy")&&(r.policy=e.output_dtype_policy,!ur(or,r.policy))?new TypeError(R("invalid option. `%s` option must be a recognized/supported output array data type policy. Option: `%s`.","output_dtype_policy",r.policy)):null:new TypeError(R("invalid argument. Options argument must be an object. Value: `%s`.",e))}V.exports=lr});var L=v(function(zr,S){"use strict";var sr=require("@stdlib/assert-is-plain-object"),C=require("@stdlib/assert-has-own-property"),I=require("@stdlib/assert-contains"),pr=require("@stdlib/ndarray-orders"),vr=require("@stdlib/ndarray-dtypes"),c=require("@stdlib/string-format"),dr=pr(),fr=vr();function cr(r,e){return sr(e)?C(e,"dtype")&&(r.dtype=e.dtype,!I(fr,r.dtype))?new TypeError(c("invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.","dtype",r.dtype)):C(e,"order")&&(r.order=e.order,!I(dr,r.order))?new TypeError(c("invalid option. `%s` option must be a recognized/supported data type. Option: `%s`.","order",r.order)):null:new TypeError(c("invalid argument. Options argument must be an object. Value: `%s`.",e))}S.exports=cr});var Y=v(function(Cr,U){"use strict";var mr=require("@stdlib/utils-define-nonenumerable-read-only-property"),D=require("@stdlib/assert-is-number").isPrimitive,M=require("@stdlib/assert-is-complex-like"),m=require("@stdlib/assert-is-ndarray-like"),g=require("@stdlib/assert-is-collection"),y=require("@stdlib/ndarray-base-buffer-dtype"),gr=require("@stdlib/ndarray-base-buffer"),N=require("@stdlib/ndarray-base-broadcast-array"),F=require("@stdlib/string-format"),yr=b(),K=T(),hr=O(),qr=_(),wr=z(),br=L();function Er(r,e){var u,n,t,i;if(i={number:null,complex:null,array:null,ndarray:null},n=qr(i,r),n||(u={policy:hr.output_dtype_policy},arguments.length>1&&(n=wr(u,e),n)))throw n;return t=d,mr(t,"assign",A),t;function d(a){var o,s,l,p,f;if(D(a)){if(i.number)return i.number(a);throw new TypeError("invalid argument. Providing a number is not supported.")}if(M(a)){if(i.complex)return i.complex(a);throw new TypeError("invalid argument. Providing a complex number is not supported.")}if(l={},arguments.length>1&&(p=br(l,arguments[1]),p))throw p;if(m(a)){if(i.ndarray===null)throw new TypeError("invalid argument. Providing an ndarray is not supported.");return s=l.dtype||K(a.dtype,u.policy),yr(i.ndarray,a,s,l.order||a.order)}if(g(a)){if(i.array===null)throw new TypeError("invalid argument. Providing an array-like object is not supported.");return o=y(a)||"generic",s=l.dtype||K(o,u.policy),f=gr(s,a.length),i.array(a.length,o,a,1,s,f,1),f}throw new TypeError(F("invalid argument. Must provide an argument having a supported data type. Value: `%s`.",a))}function A(a,o){var s,l,p;if(m(a)){if(m(o)){if(s=a.shape,l=o.shape,s.length===l.length){for(p=0;p<s.length;p++)if(s[p]!==l[p]){a=N(a,l);break}}else a=N(a,l);return i.ndarray(a,o),o}throw new TypeError("invalid argument. If the first argument is an ndarray, the second argument must be an ndarray.")}if(g(a)){if(g(o)){if(o.length!==a.length)throw new RangeError("invalid argument. Output array must have the same number of elements (i.e., length) as the input array.");return i.array(a.length,y(a)||"generic",a,1,y(o)||"generic",o,1),o}throw new TypeError("invalid argument. If the first argument is an array-like object, the second argument must be an array-like object.")}throw D(a)?new TypeError("invalid argument. Providing a number is not supported. Consider providing a zero-dimensional ndarray containing the numeric value."):M(a)?new TypeError("invalid argument. Providing a complex number is not supported. Consider providing a zero-dimensional ndarray containing the complex number value."):new TypeError(F("invalid argument. Must provide an argument having a supported data type. Value: `%s`.",a))}}U.exports=Er});var Tr=Y();module.exports=Tr;
-/**
-* @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";var O=function(a,r){return function(){return r||a((r={exports:{}}).exports,r),r.exports}};var D=O(function(tr,F){
+var H=require('@stdlib/assert-is-plain-object/dist'),V=require('@stdlib/assert-has-own-property/dist'),J=require('@stdlib/ndarray-base-assert-is-order/dist'),K=require('@stdlib/array-base-assert-contains/dist'),M=require('@stdlib/ndarray-orders/dist'),j=require('@stdlib/array-base-join/dist'),h=require('@stdlib/error-tools-fmtprodmsg/dist');function N(a,r,t){return H(t)?V(t,"dtype")&&(a.dtype=t.dtype,!K(r,String(a.dtype)))?new TypeError(h('0gz4S',"dtype",j(r,'", "'),a.dtype)):V(t,"order")&&(a.order=t.order,!J(a.order))?new TypeError(h('0gz4S',"order",j(M(),'", "'),a.order)):null:new TypeError(h('0gz2V',t));}F.exports=N
+});var z=O(function(nr,R){
+var Q=require('@stdlib/utils-define-nonenumerable-read-only-property/dist'),q=require('@stdlib/assert-is-ndarray-like/dist'),U=require('@stdlib/assert-is-function/dist'),W=require('@stdlib/assert-is-object/dist'),c=require('@stdlib/assert-is-collection/dist'),X=require('@stdlib/ndarray-base-assert-is-output-data-type-policy/dist'),Y=require('@stdlib/ndarray-base-assert-is-input-casting-policy/dist'),S=require('@stdlib/ndarray-base-assert-is-data-type/dist'),P=require('@stdlib/array-base-assert-contains/dist'),Z=require('@stdlib/ndarray-base-unary-output-dtype/dist'),C=require('@stdlib/ndarray-base-unary-input-casting-dtype/dist'),I=require('@stdlib/ndarray-base-assign/dist'),k=require('@stdlib/ndarray-base-empty/dist'),_=require('@stdlib/ndarray-maybe-broadcast-array/dist'),b=require('@stdlib/ndarray-shape/dist'),A=require('@stdlib/ndarray-order/dist'),T=require('@stdlib/ndarray-dtype/dist'),$=require('@stdlib/ndarray-empty/dist'),B=require('@stdlib/array-base-every-by/dist'),L=require('@stdlib/array-base-join/dist'),n=require('@stdlib/error-tools-fmtprodmsg/dist'),x=D();function rr(a,r,t,o){var m,d,l;if(!U(a))throw new TypeError(n('0gz3c',a));if(!c(r))throw new TypeError(n('0gz2y',r));for(l=0;l<r.length;l++)if(d=r[l],!c(d)||d.length<1||!B(d,S))throw new TypeError(n('0gzHw',r));if(!c(t)||t.length<1||!B(t,S))throw new TypeError(n('0gzHX',t));if(!W(o))throw new TypeError(n('0gz43',o));if(!X(o.output))throw new TypeError(n('0gzI6',o.output));if(!Y(o.casting))throw new TypeError(n('0gzI7',o.casting));return m={output:o.output,casting:o.casting},Q(E,"assign",G),E;function E(e){var u,i,v,s,g,y,p,f,w;if(!q(e))throw new TypeError(n('0gz4f',e));if(g=T(e),!P(r[0],g))throw new TypeError(n('0gzHZ',L(r[0],'", "'),g));if(u={},arguments.length>1&&(i=x(u,t,arguments[1]),i))throw i;return v=b(e),s=A(e),y=u.dtype||Z(g,m.output),w=$(v,{dtype:y,order:u.order||s}),f=C(g,y,m.casting),g!==f&&(p=k(f,v,s),I([e,p]),e=p),a(e,w),w}function G(e,u){var i,v,s;if(!q(e))throw new TypeError(n('0gz4f',e));if(!q(u))throw new TypeError(n('0gzF1',u));if(i=T(e),!P(r[0],i))throw new TypeError(n('0gzHZ',L(r[0],'", "'),i));return s=C(i,T(u),m.casting),i!==s&&(v=k(s,b(e),A(e)),I([e,v]),e=v),a(_(e,b(u)),u),u}}R.exports=rr
+});var er=z();module.exports=er;
+/** @license Apache-2.0 */
 //# sourceMappingURL=index.js.map