@stdlib/strided-base 0.0.7 → 0.1.0

package/docs/types/index.d.ts

@@ -16,27 +16,40 @@
 * limitations under the License.
 */
 
-// TypeScript Version: 2.0
+// TypeScript Version: 4.1
 
 /* tslint:disable:max-line-length */
 /* tslint:disable:max-file-line-count */
 
 import binary = require( '@stdlib/strided-base-binary' );
 import binaryAddonDispatch = require( '@stdlib/strided-base-binary-addon-dispatch' );
+import binaryDtypeSignatures = require( '@stdlib/strided-base-binary-dtype-signatures' );
+import binarySignatureCallbacks = require( '@stdlib/strided-base-binary-signature-callbacks' );
+import cmap = require( '@stdlib/strided-base-cmap' );
 import dmap = require( '@stdlib/strided-base-dmap' );
 import dmap2 = require( '@stdlib/strided-base-dmap2' );
 import dmskmap = require( '@stdlib/strided-base-dmskmap' );
 import dmskmap2 = require( '@stdlib/strided-base-dmskmap2' );
 import dtypeEnum2Str = require( '@stdlib/strided-base-dtype-enum2str' );
 import dtypeResolveEnum = require( '@stdlib/strided-base-dtype-resolve-enum' );
+import dtypeResolveStr = require( '@stdlib/strided-base-dtype-resolve-str' );
 import dtypeStr2Enum = require( '@stdlib/strided-base-dtype-str2enum' );
 import mapBy = require( '@stdlib/strided-base-map-by' );
 import mapBy2 = require( '@stdlib/strided-base-map-by2' );
+import maxViewBufferIndex = require( '@stdlib/strided-base-max-view-buffer-index' );
 import metaDataProps = require( '@stdlib/strided-base-meta-data-props' );
+import minViewBufferIndex = require( '@stdlib/strided-base-min-view-buffer-index' );
 import mskunary = require( '@stdlib/strided-base-mskunary' );
+import mskunaryAddonDispatch = require( '@stdlib/strided-base-mskunary-addon-dispatch' );
+import mskunaryDtypeSignatures = require( '@stdlib/strided-base-mskunary-dtype-signatures' );
+import mskunarySignatureCallbacks = require( '@stdlib/strided-base-mskunary-signature-callbacks' );
 import nullary = require( '@stdlib/strided-base-nullary' );
+import nullaryAddonDispatch = require( '@stdlib/strided-base-nullary-addon-dispatch' );
+import offsetView = require( '@stdlib/strided-base-offset-view' );
 import quaternary = require( '@stdlib/strided-base-quaternary' );
 import quinary = require( '@stdlib/strided-base-quinary' );
+import reinterpretComplex64 = require( '@stdlib/strided-base-reinterpret-complex64' );
+import reinterpretComplex128 = require( '@stdlib/strided-base-reinterpret-complex128' );
 import smap = require( '@stdlib/strided-base-smap' );
 import smap2 = require( '@stdlib/strided-base-smap2' );
 import smskmap = require( '@stdlib/strided-base-smskmap' );
@@ -44,6 +57,10 @@ import smskmap2 = require( '@stdlib/strided-base-smskmap2' );
 import ternary = require( '@stdlib/strided-base-ternary' );
 import unary = require( '@stdlib/strided-base-unary' );
 import unaryAddonDispatch = require( '@stdlib/strided-base-unary-addon-dispatch' );
+import unaryBy = require( '@stdlib/strided-base-unary-by' );
+import unaryDtypeSignatures = require( '@stdlib/strided-base-unary-dtype-signatures' );
+import unarySignatureCallbacks = require( '@stdlib/strided-base-unary-signature-callbacks' );
+import zmap = require( '@stdlib/strided-base-zmap' );
 
 /**
 * Interface describing the `base` namespace.
@@ -141,6 +158,146 @@ interface Namespace {
 	*/
 	binaryAddonDispatch: typeof binaryAddonDispatch;
 
+	/**
+	* Generates a list of binary interface signatures from strided array data types.
+	*
+	* ## Notes
+	*
+	* -   The function returns a strided array having a stride length of `3` (i.e., every `3` elements define a binary interface signature).
+	* -   For each signature (i.e., set of three consecutive non-overlapping strided array elements), the first two elements are the input data types and the third element is the return data type.
+	* -   All signatures follow type promotion rules.
+	*
+	* @param dtypes1 - list of supported data types for the first argument
+	* @param dtypes2 - list of supported data types for the second argument
+	* @param dtypes3 - list of supported data types for the output
+	* @param options - options
+	* @param options.enums - boolean flag indicating whether to return signatures as a list of enumeration constants
+	* @throws must provide recognized data types
+	* @returns strided array containing binary interface signatures
+	*
+	* @example
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = ns.binaryDtypeSignatures( dtypes, dtypes, dtypes );
+	* // returns [ 'float32', 'float32', 'float32', ... ]
+	*/
+	binaryDtypeSignatures: typeof binaryDtypeSignatures;
+
+	/**
+	* Assigns callbacks to binary interfaces according to type promotion rules.
+	*
+	* ## Notes
+	*
+	* -   The function assumes that the provided signature array has the following properties:
+	*
+	*     -   a strided array having a stride length of `3` (i.e., every `3` elements define a binary interface signature).
+	*     -   for each signature (i.e., set of three consecutive non-overlapping strided array elements), the first two elements are the input data types and the third element is the return data type.
+	*     -   all signatures follow type promotion rules.
+	*
+	* @param table - callback table
+	* @param table.default - default callback
+	* @param table.complex64 - callback for single-precision complex floating-point numbers
+	* @param table.complex128 - callback for double-precision complex floating-point numbers
+	* @param signatures - strided array containing binary interface signatures
+	* @returns list of callbacks
+	*
+	* @example
+	* var signatures = require( `@stdlib/strided/base/binary-dtype-signatures` );
+	* var add = require( `@stdlib/math/base/ops/add` );
+	* var cadd = require( `@stdlib/math/base/ops/cadd` );
+	* var caddf = require( `@stdlib/math/base/ops/caddf` );
+	*
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = signatures( dtypes, dtypes, dtypes );
+	* // returns [...]
+	*
+	* var table = {
+	*     'default': add,
+	*     'complex64': caddf,
+	*     'complex128': cadd
+	* };
+	*
+	* var list = ns.binarySignatureCallbacks( table, sigs );
+	* // returns [...]
+	*/
+	binarySignatureCallbacks: typeof binarySignatureCallbacks;
+
+	/**
+	* Applies a unary function to a single-precision complex floating-point strided input array and assigns results to a single-precision complex floating-point strided output array.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - `x` stride length
+	* @param y - destination array
+	* @param strideY - `y` stride length
+	* @param fcn - unary function to apply
+	* @returns `y`
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var real = require( `@stdlib/complex/real` );
+	* var imag = require( `@stdlib/complex/imag` );
+	* var Complex64 = require( `@stdlib/complex/float32` );
+	*
+	* function scale( x ) {
+	*     var re = real( x );
+	*     var im = imag( x );
+	*     return new Complex64( re*10.0, im*10.0 );
+	* }
+	*
+	* var x = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0 ] );
+	* var y = new Complex64Array( x.length );
+	*
+	* ns.cmap( x.length, x, 1, y, 1, scale );
+	*
+	* var v = y.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = real( v );
+	* // returns 10.0
+	*
+	* var im = imag( v );
+	* // returns 10.0
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var real = require( `@stdlib/complex/real` );
+	* var imag = require( `@stdlib/complex/imag` );
+	* var Complex64 = require( `@stdlib/complex/float32` );
+	*
+	* function scale( x ) {
+	*     var re = real( x );
+	*     var im = imag( x );
+	*     return new Complex64( re*10.0, im*10.0 );
+	* }
+	*
+	* var x = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0 ] );
+	* var y = new Complex64Array( x.length );
+	*
+	* ns.cmap.ndarray( x.length, x, 1, 0, y, 1, 0, scale );
+	*
+	* var v = y.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = real( v );
+	* // returns 10.0
+	*
+	* var im = imag( v );
+	* // returns 10.0
+	*/
+	cmap: typeof cmap;
+
 	/**
 	* Applies a unary function to a double-precision floating-point strided input array and assigns results to a double-precision floating-point strided output array.
 	*
@@ -338,6 +495,20 @@ interface Namespace {
 	*/
 	dtypeResolveEnum: typeof dtypeResolveEnum;
 
+	/**
+	* Returns the data type string associated with a strided array data type value.
+	*
+	* @param dtype - data type value
+	* @returns data type string
+	*
+	* @example
+	* var str2enum = require( `@stdlib/strided/base/dtype-str2enum` );
+	*
+	* var v = ns.dtypeResolveStr( str2enum( 'float64' ) );
+	* // returns 'float64'
+	*/
+	dtypeResolveStr: typeof dtypeResolveStr;
+
 	/**
 	* Returns the enumeration constant associated with a strided array data type string.
 	*
@@ -413,8 +584,9 @@ interface Namespace {
 	* @example
 	* var add = require( `@stdlib/math/base/ops/add` );
 	*
-	* function accessor( v1, v2 ) {
-	*     return [ v1*2.0, v2*2.0 ];
+	* function accessor( values ) {
+	*     values[ 0 ] *= 2.0;
+	*     values[ 1 ] *= 2.0;
 	* }
 	*
 	* var x = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
@@ -427,8 +599,9 @@ interface Namespace {
 	* @example
 	* var add = require( `@stdlib/math/base/ops/add` );
 	*
-	* function accessor( v1, v2 ) {
-	*     return [ v1*2.0, v2*2.0 ];
+	* function accessor( values ) {
+	*     values[ 0 ] *= 2.0;
+	*     values[ 1 ] *= 2.0;
 	* }
 	*
 	* var x = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
@@ -440,6 +613,20 @@ interface Namespace {
 	*/
 	mapBy2: typeof mapBy2;
 
+	/**
+	* Returns the maximum accessible index based on a set of provided strided array parameters.
+	*
+	* @param N - number of indexed elements
+	* @param stride - stride length
+	* @param offset - starting index
+	* @returns maximum accessible index
+	*
+	* @example
+	* var idx = ns.maxViewBufferIndex( 3, 2, 10 );
+	* // returns 14
+	*/
+	maxViewBufferIndex: typeof maxViewBufferIndex;
+
 	/**
 	* Defines non-enumerable read-only properties which expose strided array function meta data.
 	*
@@ -475,6 +662,20 @@ interface Namespace {
 	*/
 	metaDataProps: typeof metaDataProps;
 
+	/**
+	* Returns the minimum accessible index based on a set of provided strided array parameters.
+	*
+	* @param N - number of indexed elements
+	* @param stride - stride length
+	* @param offset - starting index
+	* @returns minimum accessible index
+	*
+	* @example
+	* var idx = ns.minViewBufferIndex( 3, -2, 10 );
+	* // returns 6
+	*/
+	minViewBufferIndex: typeof minViewBufferIndex;
+
 	/**
 	* Applies a unary callback to elements in a strided input array according to elements in a strided mask array and assigns results to elements in a strided output array.
 	*
@@ -526,6 +727,124 @@ interface Namespace {
 	*/
 	mskunary: typeof mskunary;
 
+	/**
+	* Returns a function which dispatches to a native add-on applying a unary function to an input strided array according to a mask strided array.
+	*
+	* @param addon - add-on function
+	* @param fallback - fallback function
+	* @returns dispatch function
+	*
+	* @example
+	* function addon( N, dtypeX, x, strideX, dtypeMask, mask, strideMask, dtypeY, y, strideY ) {
+	*     // Call into native add-on...
+	* }
+	*
+	* function fallback( N, dtypeX, x, strideX, dtypeMask, mask, strideMask, dtypeY, y, strideY ) {
+	*     // Fallback JavaScript implementation...
+	* }
+	*
+	* // Create a ns.mskunaryAddonDispatch function:
+	* var f = ns.mskunaryAddonDispatch( addon, fallback );
+	*
+	* // ...
+	*
+	* // Invoke the ns.mskunaryAddonDispatch function with strided array arguments:
+	* f( 2, 'generic', [ 1, 2 ], 1, 'generic', [ 0, 0 ], 1, 'generic', [ 0, 0 ], 1 );
+	*
+	* @example
+	* function addon( N, dtypeX, x, strideX, dtypeMask, mask, strideMask, dtypeY, y, strideY ) {
+	*     // Call into native add-on...
+	* }
+	*
+	* function fallback( N, dtypeX, x, strideX, offsetX, dtypeMask, mask, strideMask, offsetMask, dtypeY, y, strideY, offsetY ) {
+	*     // Fallback JavaScript implementation...
+	* }
+	*
+	* // Create a ns.mskunaryAddonDispatch function:
+	* var f = ns.mskunaryAddonDispatch.ndarray( addon, fallback );
+	*
+	* // ...
+	*
+	* // Invoke the ns.mskunaryAddonDispatch function with strided array arguments:
+	* f( 2, 'generic', [ 1, 2 ], 1, 0, 'generic', [ 0, 0 ], 1, 0, 'generic', [ 0, 0 ], 1, 0 );
+	*/
+	mskunaryAddonDispatch: typeof mskunaryAddonDispatch;
+
+	/**
+	* Generates a list of masked unary interface signatures from strided array data types.
+	*
+	* ## Notes
+	*
+	* -   The function returns a strided array having a stride length of `3` (i.e., every `3` elements define a masked unary interface signature).
+	* -   For each signature (i.e., set of three consecutive non-overlapping strided array elements), the first element is the input data type, the second element is the mask data type, and the last element is the return data type.
+	* -   All signatures follow type promotion rules.
+	* -   The mask array data type is always `uint8`.
+	*
+	* @param dtypes1 - list of supported data types for the first argument
+	* @param dtypes2 - list of supported data types for the output argument
+	* @param options - options
+	* @param options.enums - boolean flag indicating whether to return signatures as a list of enumeration constants
+	* @throws must provide recognized data types
+	* @returns strided array containing masked unary interface signatures
+	*
+	* @example
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = ns.mskunaryDtypeSignatures( dtypes, dtypes );
+	* // e.g., returns [ 'float32', 'uint8', 'float32', ... ]
+	*/
+	mskunaryDtypeSignatures: typeof mskunaryDtypeSignatures;
+
+	/**
+	* Assigns callbacks to masked unary interfaces according to type promotion rules.
+	*
+	* ## Notes
+	*
+	* -   The function assumes that the provided signature array has the following properties:
+	*
+	*     -   a strided array having a stride length of `3` (i.e., every `3` elements define a masked unary interface signature).
+	*     -   for each signature (i.e., set of three consecutive non-overlapping strided array elements), the first element is the input data type, the second element is the mask data type, and the last element is the return data type.
+	*     -   all signatures (excluding the mask data type) follow type promotion rules.
+	*
+	* @param table - callback table
+	* @param table.default - default callback
+	* @param table.complex64 - callback for single-precision complex floating-point numbers
+	* @param table.complex128 - callback for double-precision complex floating-point numbers
+	* @param signatures - strided array containing masked unary interface signatures
+	* @returns list of callbacks
+	*
+	* @example
+	* var signatures = require( `@stdlib/strided/base/mskunary-dtype-signatures` );
+	* var identity = require( `@stdlib/math/base/special/identity` );
+	* var cidentity = require( `@stdlib/math/base/special/cidentity` );
+	* var cidentityf = require( `@stdlib/math/base/special/cidentityf` );
+	*
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = signatures( dtypes, dtypes );
+	* // returns [...]
+	*
+	* var table = {
+	*     'default': identity,
+	*     'complex64': cidentityf,
+	*     'complex128': cidentity
+	* };
+	*
+	* var list = ns.mskunarySignatureCallbacks( table, sigs );
+	* // returns [...]
+	*/
+	mskunarySignatureCallbacks: typeof mskunarySignatureCallbacks;
+
 	/**
 	* Applies a nullary callback and assigns results to elements in a strided output array.
 	*
@@ -571,6 +890,68 @@ interface Namespace {
 	*/
 	nullary: typeof nullary;
 
+	/**
+	* Returns a function which dispatches to a native add-on applying a nullary function.
+	*
+	* @param addon - add-on function
+	* @param fallback - fallback function
+	* @returns dispatch function
+	*
+	* @example
+	* function addon( N, dtypeX, x, strideX ) {
+	*     // Call into native add-on...
+	* }
+	*
+	* function fallback( N, dtypeX, x, strideX ) {
+	*     // Fallback JavaScript implementation...
+	* }
+	*
+	* // Create a ns.nullaryAddonDispatch function:
+	* var f = ns.nullaryAddonDispatch( addon, fallback );
+	*
+	* // ...
+	*
+	* // Invoke the ns.nullaryAddonDispatch function with strided array arguments:
+	* f( 2, 'generic', [ 1, 2 ], 1 );
+	*
+	* @example
+	* function addon( N, dtypeX, x, strideX ) {
+	*     // Call into native add-on...
+	* }
+	*
+	* function fallback( N, dtypeX, x, strideX, offsetX ) {
+	*     // Fallback JavaScript implementation...
+	* }
+	*
+	* // Create a ns.nullaryAddonDispatch function:
+	* var f = ns.nullaryAddonDispatch.ndarray( addon, fallback );
+	*
+	* // ...
+	*
+	* // Invoke the ns.nullaryAddonDispatch function with strided array arguments:
+	* f( 2, 'generic', [ 1, 2 ], 1, 0 );
+	*/
+	nullaryAddonDispatch: typeof nullaryAddonDispatch;
+
+	/**
+	* Returns a typed array view having the same data type as a provided input typed array and starting at a specified index offset.
+	*
+	* @param x - input array
+	* @param offset - starting index
+	* @returns typed array view
+	*
+	* @example
+	* var Float64Array = require( `@stdlib/array/float64` );
+	*
+	* var x = new Float64Array( 10 );
+	*
+	* var out = ns.offsetView( x, 0 );
+	* // returns <Float64Array>
+	*
+	* var bool = ( out.buffer === x.buffer );
+	*/
+	offsetView: typeof offsetView;
+
 	/**
 	* Applies a quaternary callback to strided input array elements and assigns results to elements in a strided output array.
 	*
@@ -679,6 +1060,44 @@ interface Namespace {
 	*/
 	quinary: typeof quinary;
 
+	/**
+	* Reinterprets a `Complex64Array` as a `Float32Array`.
+	*
+	* @param x - input array
+	* @param offset - starting index
+	* @returns `Float32Array` view
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	*
+	* var x = new Complex64Array( 10 );
+	*
+	* var out = ns.reinterpretComplex64( x, 0 );
+	* // returns <Float32Array>
+	*
+	* var bool = ( out.buffer === x.buffer );
+	*/
+	reinterpretComplex64: typeof reinterpretComplex64;
+
+	/**
+	* Reinterprets a `Complex128Array` as a `Float64Array`.
+	*
+	* @param x - input array
+	* @param offset - starting index
+	* @returns `Float64Array` view
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	*
+	* var x = new Complex128Array( 10 );
+	*
+	* var out = ns.reinterpretComplex128( x, 0 );
+	* // returns <Float64Array>
+	*
+	* var bool = ( out.buffer === x.buffer );
+	*/
+	reinterpretComplex128: typeof reinterpretComplex128;
+
 	/**
 	* Applies a unary function to a single-precision floating-point strided input array and assigns results to a single-precision floating-point strided output array.
 	*
@@ -983,6 +1402,190 @@ interface Namespace {
 	* f( 2, 'generic', [ 1, 2 ], 1, 0, 'generic', [ 0, 0 ], 1, 0 );
 	*/
 	unaryAddonDispatch: typeof unaryAddonDispatch;
+
+	/**
+	* Applies a unary function to each element retrieved from a strided input array according to a callback function and assigns results to a strided output array.
+	*
+	* @param arrays - array-like object containing one input array and one output array
+	* @param shape - array-like object containing a single element, the number of indexed elements
+	* @param strides - array-like object containing the stride lengths for the input and output arrays
+	* @param fcn - unary function to apply to callback return values
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	*
+	* @example
+	* var abs = require( `@stdlib/math/base/special/abs` );
+	*
+	* function accessor( v ) {
+	*     return v * 2.0;
+	* }
+	*
+	* var x = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
+	* var y = [ 0.0, 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* var shape = [ x.length ];
+	* var strides = [ 1, 1 ];
+	*
+	* ns.unaryBy( [ x, y ], shape, strides, abs, accessor );
+	* // y => [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
+	*
+	* @example
+	* var abs = require( `@stdlib/math/base/special/abs` );
+	*
+	* function accessor( v ) {
+	*     return v * 2.0;
+	* }
+	*
+	* var x = [ 1.0, -2.0, 3.0, -4.0, 5.0 ];
+	* var y = [ 0.0, 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* var shape = [ x.length ];
+	* var strides = [ 1, 1 ];
+	* var offsets = [ 0, 0 ];
+	*
+	* ns.unaryBy.ndarray( [ x, y ], shape, strides, offsets, abs, accessor );
+	* // y => [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
+	*/
+	unaryBy: typeof unaryBy;
+
+	/**
+	* Generates a list of unary interface signatures from strided array data types.
+	*
+	* ## Notes
+	*
+	* -   The function returns a strided array having a stride length of `2` (i.e., every `2` elements define a unary interface signature).
+	* -   For each signature (i.e., set of two consecutive non-overlapping strided array elements), the first element is the input data type and the second element is the return data type.
+	* -   All signatures follow type promotion rules.
+	*
+	* @param dtypes1 - list of supported data types for the first argument
+	* @param dtypes2 - list of supported data types for the output argument
+	* @param options - options
+	* @param options.enums - boolean flag indicating whether to return signatures as a list of enumeration constants
+	* @throws must provide recognized data types
+	* @returns strided array containing unary interface signatures
+	*
+	* @example
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = ns.unaryDtypeSignatures( dtypes, dtypes );
+	* // e.g., returns [ 'float32', 'float32', ... ]
+	*/
+	unaryDtypeSignatures: typeof unaryDtypeSignatures;
+
+	/**
+	* Assigns callbacks to unary interfaces according to type promotion rules.
+	*
+	* ## Notes
+	*
+	* -   The function assumes that the provided signature array has the following properties:
+	*
+	*     -   a strided array having a stride length of `2` (i.e., every `2` elements define a unary interface signature).
+	*     -   for each signature (i.e., set of two consecutive non-overlapping strided array elements), the first element is the input data type and the second element is the return data type.
+	*     -   all signatures follow type promotion rules.
+	*
+	* @param table - callback table
+	* @param table.default - default callback
+	* @param table.complex64 - callback for single-precision complex floating-point numbers
+	* @param table.complex128 - callback for double-precision complex floating-point numbers
+	* @param signatures - strided array containing unary interface signatures
+	* @returns list of callbacks
+	*
+	* @example
+	* var signatures = require( `@stdlib/strided/base/unary-dtype-signatures` );
+	* var identity = require( `@stdlib/math/base/special/identity` );
+	* var cidentity = require( `@stdlib/math/base/special/cidentity` );
+	* var cidentityf = require( `@stdlib/math/base/special/cidentityf` );
+	*
+	* var dtypes = [
+	*     'float64',
+	*     'float32',
+	*     'int32',
+	*     'uint8'
+	* ];
+	*
+	* var sigs = signatures( dtypes, dtypes );
+	* // returns [...]
+	*
+	* var table = {
+	*     'default': identity,
+	*     'complex64': cidentityf,
+	*     'complex128': cidentity
+	* };
+	*
+	* var list = ns.unarySignatureCallbacks( table, sigs );
+	* // returns [...]
+	*/
+	unarySignatureCallbacks: typeof unarySignatureCallbacks;
+
+	/**
+	* Applies a unary function to a double-precision complex floating-point strided input array and assigns results to a double-precision complex floating-point strided output array.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - `x` stride length
+	* @param y - destination array
+	* @param strideY - `y` stride length
+	* @param fcn - unary function to apply
+	* @returns `y`
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	* var real = require( `@stdlib/complex/real` );
+	* var imag = require( `@stdlib/complex/imag` );
+	* var Complex128 = require( `@stdlib/complex/float64` );
+	*
+	* function scale( x ) {
+	*     var re = real( x );
+	*     var im = imag( x );
+	*     return new Complex128( re*10.0, im*10.0 );
+	* }
+	*
+	* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0 ] );
+	* var y = new Complex128Array( x.length );
+	*
+	* ns.zmap( x.length, x, 1, y, 1, scale );
+	*
+	* var v = y.get( 0 );
+	* // returns <Complex128>
+	*
+	* var re = real( v );
+	* // returns 10.0
+	*
+	* var im = imag( v );
+	* // returns 10.0
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	* var real = require( `@stdlib/complex/real` );
+	* var imag = require( `@stdlib/complex/imag` );
+	* var Complex128 = require( `@stdlib/complex/float64` );
+	*
+	* function scale( x ) {
+	*     var re = real( x );
+	*     var im = imag( x );
+	*     return new Complex128( re*10.0, im*10.0 );
+	* }
+	*
+	* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0 ] );
+	* var y = new Complex128Array( x.length );
+	*
+	* ns.zmap.ndarray( x.length, x, 1, 0, y, 1, 0, scale );
+	*
+	* var v = y.get( 0 );
+	* // returns <Complex128>
+	*
+	* var re = real( v );
+	* // returns 10.0
+	*
+	* var im = imag( v );
+	* // returns 10.0
+	*/
+	zmap: typeof zmap;
 }
 
 /**