@stdlib/array-complex64 0.1.0 → 0.2.1

package/docs/types/index.d.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-lines */
+
 /*
 * @license Apache-2.0
 *
@@ -28,6 +30,225 @@ import ArrayBuffer = require( '@stdlib/array-buffer' );
 // Define a union type representing both iterable and non-iterable iterators:
 type Iterator = Iter | IterableIterator;
 
+/**
+* Callback invoked for each element in a source object.
+*
+* @returns transformed value
+*/
+type FromNullary<U> = ( this: U ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in a source object.
+*
+* @param value - source element
+* @returns transformed value
+*/
+type FromUnary<U> = ( this: U, value: ComplexLike | ArrayLike<number> | number ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in a source object.
+*
+* @param value - source element
+* @param index - source element index
+* @returns transformed value
+*/
+type FromBinary<U> = ( this: U, value: ComplexLike | ArrayLike<number> | number, index: number ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in a source object.
+*
+* @param value - source element
+* @param index - source element index
+* @returns transformed value
+*/
+type FromCallback<U> = FromNullary<U> | FromUnary<U> | FromBinary<U>;
+
+/**
+* Checks whether an element in an array passes a test.
+*
+* @returns boolean indicating whether an element in an array passes a test
+*/
+type NullaryPredicate<U> = ( this: U ) => boolean;
+
+/**
+* Checks whether an element in an array passes a test.
+*
+* @param value - current array element
+* @returns boolean indicating whether an element in an array passes a test
+*/
+type UnaryPredicate<U> = ( this: U, value: Complex64 ) => boolean;
+
+/**
+* Checks whether an element in an array passes a test.
+*
+* @param value - current array element
+* @param index - current array element index
+* @returns boolean indicating whether an element in an array passes a test
+*/
+type BinaryPredicate<U> = ( this: U, value: Complex64, index: number ) => boolean;
+
+/**
+* Checks whether an element in an array passes a test.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns boolean indicating whether an element in an array passes a test
+*/
+type TernaryPredicate<U> = ( this: U, value: Complex64, index: number, arr: Complex64Array ) => boolean;
+
+/**
+* Checks whether an element in an array passes a test.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns boolean indicating whether an element in an array passes a test
+*/
+type Predicate<U> = NullaryPredicate<U> | UnaryPredicate<U> | BinaryPredicate<U> | TernaryPredicate<U>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @returns undefined
+*/
+type NullaryCallback<U> = ( this: U ) => void;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @returns undefined
+*/
+type UnaryCallback<U> = ( this: U, value: Complex64 ) => void;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @returns undefined
+*/
+type BinaryCallback<U> = ( this: U, value: Complex64, index: number ) => void;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns undefined
+*/
+type TernaryCallback<U> = ( this: U, value: Complex64, index: number, arr: Complex64Array ) => void;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns undefined
+*/
+type Callback<U> = NullaryCallback<U> | UnaryCallback<U> | BinaryCallback<U> | TernaryCallback<U>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @returns transformed value
+*/
+type NullaryMapFcn<U> = ( this: U ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @returns transformed value
+*/
+type UnaryMapFcn<U> = ( this: U, value: Complex64 ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @returns transformed value
+*/
+type BinaryMapFcn<U> = ( this: U, value: Complex64, index: number ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns transformed value
+*/
+type TernaryMapFcn<U> = ( this: U, value: Complex64, index: number, arr: Complex64Array ) => ComplexLike | ArrayLike<number>;
+
+/**
+* Callback invoked for each element in an array.
+*
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns transformed value
+*/
+type MapFcn<U> = NullaryMapFcn<U> | UnaryMapFcn<U> | BinaryMapFcn<U> | TernaryMapFcn<U>;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @returns accumulated result
+*/
+type NullaryReducer<U> = () => U;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @returns accumulated result
+*/
+type UnaryReducer<U> = ( acc: U ) => U;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @returns accumulated result
+*/
+type BinaryReducer<U> = ( acc: U, value: Complex64 ) => U;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @returns accumulated result
+*/
+type TernaryReducer<U> = ( acc: U, value: Complex64, index: number ) => U;
+
+/**
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns accumulated result
+*/
+type QuaternaryReducer<U> = ( acc: U, value: Complex64, index: number, arr: Complex64Array ) => U;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns accumulated result
+*/
+type Reducer<U> = NullaryReducer<U> | UnaryReducer<U> | BinaryReducer<U> | TernaryReducer<U> | QuaternaryReducer<U>;
+
 /**
 * Class for creating a 64-bit complex number array.
 */
@@ -70,7 +291,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf );
@@ -80,7 +301,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* // returns 2
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf, 8 );
@@ -90,7 +311,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 32 );
 	* var arr = new Complex64Array( buf, 8, 2 );
@@ -99,7 +320,34 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* var len = arr.length;
 	* // returns 2
 	*/
-	constructor( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number ); // tslint:disable-line:max-line-length
+	constructor( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number );
+
+	/**
+	* Returns an array element with support for both nonnegative and negative integer indices.
+	*
+	* @param i - element index
+	* @throws index argument must be a integer
+	* @returns array element
+	*
+	* @example
+	* var arr = new Complex64Array( 10 );
+	*
+	* var z = arr.at( 0 );
+	* // returns <Complex64>
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 9.0, -9.0 ], 9 );
+	*
+	* z = arr.get( -1 )
+	* // return <Complex64>
+	*
+	* z = arr.at( 100 );
+	* // returns undefined
+	*
+	* z = arr.at( -100 );
+	* // returns undefined
+	*/
+	at( i: number ): Complex64 | void;
 
 	/**
 	* Length (in bytes) of the array.
@@ -154,9 +402,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns modified array
 	*
 	* @example
-	* var Complex64 = require( `@stdlib/complex/float32` );
-	* var realf = require( `@stdlib/complex/realf` );
-	* var imagf = require( `@stdlib/complex/imagf` );
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
 	*
 	* var arr = new Complex64Array( 4 );
 	*
@@ -186,7 +434,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns iterator
 	*
 	* @example
-	* var Complex64 = require( `@stdlib/complex/float32` );
+	* var Complex64 = require( '@stdlib/complex-float32' );
 	*
 	* var arr = [
 	*     new Complex64( 1.0, 1.0 ),
@@ -214,83 +462,809 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	entries(): Iterator;
 
 	/**
-	* Returns an array element.
+	* Tests whether all elements in an array pass a test implemented by a predicate function.
 	*
-	* @param i - element index
-	* @throws index argument must be a nonnegative integer
-	* @returns array element
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns boolean indicating whether all elements pass a test
 	*
 	* @example
-	* var arr = new Complex64Array( 10 );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
 	*
-	* var z = arr.get( 0 );
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0 , 1.0 ], 0 );
+	* arr.set( [ 2.0 , 2.0 ], 1 );
+	* arr.set( [ 3.0 , 3.0 ], 2 );
+	*
+	* var bool = arr.every( predicate );
+	* // returns true
+	*/
+	every<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): boolean;
+
+	/**
+	* Returns a modified typed array filled with a fill value.
+	*
+	* @param value - fill value
+	* @param start - starting index (inclusive)
+	* @param end - ending index (exclusive)
+	* @returns modified typed array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.fill( new Complex64( 1.0, 1.0 ), 1 );
+	*
+	* var z = arr.get( 1 );
 	* // returns <Complex64>
 	*
-	* arr.set( [ 1.0, -1.0 ], 0 );
+	* var re = realf( z );
+	* // returns 1.0
 	*
-	* z = arr.get( 100 );
-	* // returns undefined
+	* var im = imagf( z );
+	* // returns 1.0
+	*
+	* z = arr.get( 2 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 1.0
+	*
+	* im = imagf( z );
+	* // returns 1.0
 	*/
-	get( i: number ): Complex64 | void;
+	fill( value: ComplexLike, start?: number, end?: number ): Complex64Array;
 
 	/**
-	* Sets an array element.
+	* Returns a new array containing the elements of an array which pass a test implemented by a predicate function.
 	*
-	* ## Notes
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns new array containing elements which pass a test implemented by a predicate function
 	*
-	* -   When provided a typed array, real or complex, we must check whether the source array shares the same buffer as the target array and whether the underlying memory overlaps. In particular, we are concerned with the following scenario:
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
 	*
-	*     ```text
-	*     buf:                ---------------------
-	*     src: ---------------------
-	*     ```
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
 	*
-	*     In the above, as we copy values from `src`, we will overwrite values in the `src` view, resulting in duplicated values copied into the end of `buf`, which is not intended. Hence, to avoid overwriting source values, we must **copy** source values to a temporary array.
+	* var arr = new Complex64Array( 3 );
 	*
-	*     In the other overlapping scenario,
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
 	*
-	*     ```text
-	*     buf: ---------------------
-	*     src:                ---------------------
-	*     ```
+	* var out = arr.filter( predicate );
+	* // returns <Complex64Array>
 	*
-	*     by the time we begin copying into the overlapping region, we are copying from the end of `src`, a non-overlapping region, which means we don't run the risk of copying copied values, rather than the original `src` values as intended.
+	* var len = out.length;
+	* // returns 1
 	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
 	*
-	* @param value - value(s)
-	* @param i - element index at which to start writing values (default: 0)
-	* @throws index argument must be a nonnegative integer
-	* @throws array-like objects must have a length which is a multiple of two
-	* @throws index argument is out-of-bounds
-	* @throws target array lacks sufficient storage to accommodate source values
+	* var re = realf( z );
+	* // returns 2.0
+	*
+	* var im = imagf( z );
+	* // returns 2.0
+	*/
+	filter<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): Complex64Array;
+
+	/**
+	* Returns the first element in an array for which a predicate function returns a truthy value.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns array element or undefined
 	*
 	* @example
-	* var realf = require( `@stdlib/complex/realf` );
-	* var imagf = require( `@stdlib/complex/imagf` );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	* var Complex64 = require( '@stdlib/complex-float32' );
 	*
-	* var arr = new Complex64Array( 10 );
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
 	*
-	* var z = arr.get( 0 );
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var z = arr.find( predicate );
 	* // returns <Complex64>
 	*
 	* var re = realf( z );
-	* // returns 0.0
+	* // returns 1.0
 	*
 	* var im = imagf( z );
-	* // returns 0.0
+	* // returns 1.0
+	*/
+	find<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): Complex64 | void;
+
+	/**
+	* Returns the index of the first element in an array for which a predicate function returns a truthy value.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns index or -1
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
 	*
 	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
 	*
-	* z = arr.get( 0 );
+	* var idx = arr.findIndex( predicate );
+	* // returns 2
+	*/
+	findIndex<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): number;
+
+	/**
+	* Returns the last element in an array for which a predicate function returns a truthy value.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns array element or undefined
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	*
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var z = arr.findLast( predicate );
 	* // returns <Complex64>
 	*
-	* re = realf( z );
-	* // returns 1.0
+	* var re = realf( z );
+	* // returns 3.0
 	*
-	* im = imagf( z );
-	* // returns -1.0
+	* var im = imagf( z );
+	* // returns 3.0
+	*/
+	findLast<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): Complex64 | void;
+
+	/**
+	* Returns the index of the last element in an array for which a predicate function returns a truthy value.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns index or -1
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	*
+	* var idx = arr.findLastIndex( predicate );
+	* // returns 1
+	*/
+	findLastIndex<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): number;
+
+	/**
+	* Invokes a function once for each array element.
+	*
+	* @param fcn - function to invoke
+	* @param thisArg - execution context
+	* @returns undefined
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	*
+	* function log( v, i ) {
+	*     console.log( '%s: %s', i, v.toString() );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* arr.forEach( log );
+	* // => 0: 1 + 1i
+	* // => 1: 2 + 2i
+	* // => 2: 3 + 3i
+	*/
+	forEach<U = unknown>( fcn: Callback<U>, thisArg?: ThisParameterType<Callback<U>> ): void;
+
+	/**
+	* Returns an array element.
+	*
+	* @param i - element index
+	* @throws index argument must be a nonnegative integer
+	* @returns array element
+	*
+	* @example
+	* var arr = new Complex64Array( 10 );
+	*
+	* var z = arr.get( 0 );
+	* // returns <Complex64>
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	*
+	* z = arr.get( 100 );
+	* // returns undefined
+	*/
+	get( i: number ): Complex64 | void;
+
+	/**
+	* Returns a boolean indicating whether an array contains a provided value.
+	*
+	* @param searchElement - search element
+	* @param fromIndex - starting index (inclusive)
+	* @returns boolean indicating whether an array contains a provided value
+	*
+	* @example
+	* var arr = new Complex64Array( 5 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	* arr.set( [ 4.0, -4.0 ], 3 );
+	* arr.set( [ 5.0, -5.0 ], 4 );
+	*
+	* var bool = arr.includes( new Complex64( 3.0, -3.0 ) );
+	* // returns true
+	*
+	* bool = arr.includes( new Complex64( 3.0, -3.0 ), 3 );
+	* // returns false
+	*
+	* bool = arr.includes( new Complex64( 4.0, -4.0 ), -3 );
+	* // returns true
+	*/
+	includes( searchElement: ComplexLike, fromIndex?: number ): boolean;
+
+	/**
+	* Returns the first index at which a given element can be found.
+	*
+	* @param searchElement - element to find
+	* @param fromIndex - starting index (inclusive)
+	* @returns index or -1
+	*
+	* @example
+	* var arr = new Complex64Array( 5 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	* arr.set( [ 2.0, 2.0 ], 3 );
+	* arr.set( [ 5.0, 5.0 ], 4 );
+	*
+	* var idx = arr.indexOf( new Complex64( [ 2.0, 2.0 ] ) );
+	* // returns 1
+	*
+	* idx = arr.indexOf( new Complex64( [ 2.0, 2.0 ] ), 2 );
+	* // returns 3
+	*
+	* idx = arr.indexOf( new Complex64( [ 2.0, 2.0 ] ), -3 );
+	* // returns 3
+	*/
+	indexOf( searchElement: ComplexLike, fromIndex?: number ): number;
+
+	/**
+	* Returns a new string by concatenating all array elements.
+	*
+	* @param separator - value separator (default: ',')
+	* @returns string
+	*
+	* @example
+	* var arr = new Complex64Array( 2 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	*
+	* var str = arr.join();
+	* // returns '1 + 1i,2 + 2i'
+	*
+	* str = arr.join( '/' );
+	* // returns '1 + 1i/2 + 2i'
+	*/
+	join( separator?: string ): string;
+
+	/**
+	* Returns the last index at which a given element can be found.
+	*
+	* @param searchElement - element to find
+	* @param fromIndex - index at which to start searching backward (inclusive)
+	* @returns index or -1
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	*
+	* var arr = new Complex64Array( 5 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	* arr.set( [ 4.0, -4.0 ], 3 );
+	* arr.set( [ 3.0, -3.0 ], 4 );
+	*
+	* var idx = arr.lastIndexOf( new Complex64( 3.0, -3.0 ) );
+	* // returns 4
+	*
+	* idx = arr.lastIndexOf( new Complex64( 3.0, -3.0 ), 3 );
+	* // returns 2
+	*
+	* idx = arr.lastIndexOf( new Complex64( 2.0, -2.0 ), -3 );
+	* // returns 1
+	*/
+	lastIndexOf( searchElement: ComplexLike, fromIndex?: number ): number;
+
+	/**
+	* Returns a new array with each element being the result of a provided callback function.
+	*
+	* @param fcn - callback function
+	* @param thisArg - execution context
+	* @returns new array containing transformed elements
+	*
+	* @example
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* function scale( v, i ) {
+	*     return new Complex64( 2.0*realf( v ), 2.0*imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	*
+	* var out = arr.map( scale );
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 2.0
+	*
+	* var im = imagf( z );
+	* // returns -2.0
+	*/
+	map<U = unknown>( fcn: MapFcn<U>, thisArg?: ThisParameterType<MapFcn<U>> ): Complex64Array;
+
+	/**
+	* Applies a provided callback function to each element of the array, in order, passing in the return value from the calculation on the preceding element and returning the accumulated result upon completion.
+	*
+	* @param reducer - callback function
+	* @param initialValue - initial value
+	* @returns accumulated result
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	* var caddf = require( '@stdlib/math-base-ops-caddf' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var z = arr.reduce( caddf );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 6.0
+	*
+	* var im = imagf( z );
+	* // returns 6.0
+	*/
+	reduce<U = unknown>( reducer: Reducer<U>, initialValue?: U ): U;
+
+	/**
+	* Reverses an array in-place.
+	*
+	* @returns reversed array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var out = arr.reverse();
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 3.0
+	*
+	* var im = imagf( z );
+	* // returns 3.0
+	*
+	* z = out.get( 1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 2.0
+	*
+	* im = imagf( z );
+	* // returns 2.0
+	*
+	* z = out.get( 2 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 1.0
+	*
+	* im = imagf( z );
+	* // returns 1.0
+	*/
+	reverse(): Complex64Array;
+
+	/**
+	* Sets an array element.
+	*
+	* ## Notes
+	*
+	* -   When provided a typed array, real or complex, we must check whether the source array shares the same buffer as the target array and whether the underlying memory overlaps. In particular, we are concerned with the following scenario:
+	*
+	*     ```text
+	*     buf:                ---------------------
+	*     src: ---------------------
+	*     ```
+	*
+	*     In the above, as we copy values from `src`, we will overwrite values in the `src` view, resulting in duplicated values copied into the end of `buf`, which is not intended. Hence, to avoid overwriting source values, we must **copy** source values to a temporary array.
+	*
+	*     In the other overlapping scenario,
+	*
+	*     ```text
+	*     buf: ---------------------
+	*     src:                ---------------------
+	*     ```
+	*
+	*     by the time we begin copying into the overlapping region, we are copying from the end of `src`, a non-overlapping region, which means we don't run the risk of copying copied values, rather than the original `src` values as intended.
+	*
+	*
+	* @param value - value(s)
+	* @param i - element index at which to start writing values (default: 0)
+	* @throws index argument must be a nonnegative integer
+	* @throws array-like objects must have a length which is a multiple of two
+	* @throws index argument is out-of-bounds
+	* @throws target array lacks sufficient storage to accommodate source values
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 10 );
+	*
+	* var z = arr.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 0.0
+	*
+	* var im = imagf( z );
+	* // returns 0.0
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	*
+	* z = arr.get( 0 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 1.0
+	*
+	* im = imagf( z );
+	* // returns -1.0
+	*/
+	set( value: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | ComplexLike, i?: number ): void;
+
+	/**
+	* Copies a portion of a typed array to a new typed array.
+	*
+	* @param start - starting index (inclusive)
+	* @param end - ending index (exclusive)
+	* @throws indices must be integers
+	* @returns output array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 5 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	* arr.set( [ 4.0, -4.0 ], 3 );
+	* arr.set( [ 5.0, -5.0 ], 4 );
+	*
+	* var out = arr.slice();
+	* // returns <Complex64Array>
+	*
+	* var len = out.length;
+	* // returns 5
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* var im = imagf( z );
+	* // returns -1.0
+	*
+	* z = out.get( len-1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 5.0
+	*
+	* im = imagf( z );
+	* // returns -5.0
+	*
+	* out = arr.slice( 1, -2 );
+	* // returns <Complex64Array>
+	*
+	* len = out.length;
+	* // returns 2
+	*
+	* z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 2.0
+	*
+	* im = imagf( z );
+	* // returns -2.0
+	*
+	* z = out.get( len-1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 3.0
+	*
+	* im = imagf( z );
+	* // returns -3.0
+	*/
+	slice( start?: number, end?: number ): Complex64Array;
+
+	/**
+	* Tests whether at least one element in an array passes a test implemented by a predicate function.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns boolean indicating whether at least one element passes a test
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* function predicate( v ) {
+	*     return ( realf( v ) === imagf( v ) );
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0 , -1.0 ], 0 );
+	* arr.set( [ 2.0 , 2.0 ], 1 );
+	* arr.set( [ 3.0 , -3.0 ], 2 );
+	*
+	* var bool = arr.some( predicate );
+	* // returns true
+	*/
+	some<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): boolean;
+
+	/**
+	* Creates a new typed array view over the same underlying `ArrayBuffer` and with the same underlying data type as the host array.
+	*
+	* @param begin - starting index (inclusive)
+	* @param end - ending index (exclusive)
+	* @throws indices must be integers
+	* @returns subarray
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 5 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	* arr.set( [ 3.0, -3.0 ], 2 );
+	* arr.set( [ 4.0, -4.0 ], 3 );
+	* arr.set( [ 5.0, -5.0 ], 4 );
+	*
+	* var subarr = arr.subarray();
+	* // returns <Complex64Array>
+	*
+	* var len = subarr.length;
+	* // returns 5
+	*
+	* var z = subarr.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* var im = imagf( z );
+	* // returns -1.0
+	*
+	* z = subarr.get( len-1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 5.0
+	*
+	* im = imagf( z );
+	* // returns -5.0
+	*
+	* subarr = arr.subarray( 1, -2 );
+	* // returns <Complex64Array>
+	*
+	* len = subarr.length;
+	* // returns 2
+	*
+	* z = subarr.get( 0 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 2.0
+	*
+	* im = imagf( z );
+	* // returns -2.0
+	*
+	* z = subarr.get( len-1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 3.0
+	*
+	* im = imagf( z );
+	* // returns -3.0
+	*/
+	subarray( begin?: number, end?: number ): Complex64Array;
+
+	/**
+	* Returns a new typed array containing the elements in reversed order.
+	*
+	* @returns reversed array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var out = arr.toReversed();
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 3.0
+	*
+	* var im = imagf( z );
+	* // returns 3.0
+	*
+	* z = out.get( 1 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 2.0
+	*
+	* im = imagf( z );
+	* // returns 2.0
+	*
+	* z = out.get( 2 );
+	* // returns <Complex64>
+	*
+	* re = realf( z );
+	* // returns 1.0
+	*
+	* im = imagf( z );
+	* // returns 1.0
+	*/
+	toReversed(): Complex64Array;
+
+	/**
+	* Serializes an array as a string.
+	*
+	* @returns string
+	*
+	* @example
+	* var arr = new Complex64Array( 2 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	*
+	* var str = arr.toString();
+	* // returns '1 + 1i,2 + 2i'
+	*/
+	toString(): string;
+
+	/**
+	* Returns a new typed array with the element at a provided index replaced with a provided value.
+	*
+	* @param index - element index
+	* @param value - new value
+	* @throws first argument must be an integer
+	* @throws second argument must be a complex number
+	* @throws index argument is out-of-bounds
+	* @returns modified typed array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var out = arr.with( 0, new Complex64( 4.0, 4.0 ) );
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 4.0
+	*
+	* var im = imagf( z );
+	* // returns 4.0
 	*/
-	set( value: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | ComplexLike, i?: number ): void; // tslint:disable-line:max-line-length
+	with( index: number, value: ComplexLike ): Complex64Array;
 }
 
 /**
@@ -335,7 +1309,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf );
@@ -345,7 +1319,7 @@ interface Complex64ArrayConstructor {
 	* // returns 2
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf, 8 );
@@ -355,7 +1329,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 32 );
 	* var arr = new Complex64Array( buf, 8, 2 );
@@ -364,7 +1338,7 @@ interface Complex64ArrayConstructor {
 	* var len = arr.length;
 	* // returns 2
 	*/
-	new( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number ): Complex64Array; // tslint-disable-line max-line-length
+	new( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number ): Complex64Array;
 
 	/**
 	* 64-bit complex number array constructor.
@@ -404,7 +1378,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf );
@@ -414,7 +1388,7 @@ interface Complex64ArrayConstructor {
 	* // returns 2
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 16 );
 	* var arr = new Complex64Array( buf, 8 );
@@ -424,7 +1398,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var ArrayBuffer = require( `@stdlib/array/buffer` );
+	* var ArrayBuffer = require( '@stdlib/array-buffer' );
 	*
 	* var buf = new ArrayBuffer( 32 );
 	* var arr = new Complex64Array( buf, 8, 2 );
@@ -433,7 +1407,7 @@ interface Complex64ArrayConstructor {
 	* var len = arr.length;
 	* // returns 2
 	*/
-	( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number ): Complex64Array; // tslint-disable-line max-line-length
+	( arg?: number | RealOrComplexTypedArray | ArrayLike<number | ComplexLike> | ArrayBuffer | Iterable<number | ComplexLike>, byteOffset?: number, length?: number ): Complex64Array;
 
 	/**
 	* Constructor name.
@@ -472,7 +1446,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var Complex64 = require( `@stdlib/complex/float32` );
+	* var Complex64 = require( '@stdlib/complex-float32' );
 	*
 	* var arr = Complex64Array.from( [ new Complex64( 1.0, 1.0 ) ] );
 	* // returns <Complex64Array>
@@ -481,9 +1455,9 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var Complex64 = require( `@stdlib/complex/float32` );
-	* var realf = require( `@stdlib/complex/realf` );
-	* var imagf = require( `@stdlib/complex/imagf` );
+	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-realf' );
+	* var imagf = require( '@stdlib/complex-imagf' );
 	*
 	* function clbk( v ) {
 	*     return new Complex64( realf(v)*2.0, imagf(v)*2.0 );
@@ -495,7 +1469,7 @@ interface Complex64ArrayConstructor {
 	* var len = arr.length;
 	* // returns 1
 	*/
-	from( src: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | Iterable<number | ComplexLike>, clbk?: Function, thisArg?: any ): Complex64Array; // tslint:disable-line:max-line-length
+	from( src: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | Iterable<number | ComplexLike>, clbk?: FromCallback<U>, thisArg?: ThisParameterType<FromCallback<U>> ): Complex64Array;
 
 	/**
 	* Creates a new 64-bit complex number array from a variable number of arguments.
@@ -551,7 +1525,7 @@ interface Complex64ArrayConstructor {
 * // returns 1
 *
 * @example
-* var ArrayBuffer = require( `@stdlib/array/buffer` );
+* var ArrayBuffer = require( '@stdlib/array-buffer' );
 *
 * var buf = new ArrayBuffer( 16 );
 * var arr = new Complex64Array( buf );
@@ -561,7 +1535,7 @@ interface Complex64ArrayConstructor {
 * // returns 2
 *
 * @example
-* var ArrayBuffer = require( `@stdlib/array/buffer` );
+* var ArrayBuffer = require( '@stdlib/array-buffer' );
 *
 * var buf = new ArrayBuffer( 16 );
 * var arr = new Complex64Array( buf, 8 );
@@ -571,7 +1545,7 @@ interface Complex64ArrayConstructor {
 * // returns 1
 *
 * @example
-* var ArrayBuffer = require( `@stdlib/array/buffer` );
+* var ArrayBuffer = require( '@stdlib/array-buffer' );
 *
 * var buf = new ArrayBuffer( 32 );
 * var arr = new Complex64Array( buf, 8, 2 );