@stdlib/array-complex64 0.1.0 → 0.2.0

package/docs/types/index.d.ts

@@ -1,3 +1,5 @@
+/* eslint-disable max-lines */
+
 /*
 * @license Apache-2.0
 *
@@ -28,6 +30,171 @@ 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>;
+
 /**
 * Class for creating a 64-bit complex number array.
 */
@@ -70,7 +237,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 +247,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 +257,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 +266,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 +348,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 +380,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 ),
@@ -213,6 +407,253 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	entries(): Iterator;
 
+	/**
+	* Tests whether all elements in an array pass a test implemented by a predicate function.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns boolean indicating whether all elements pass 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.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>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* 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
+	*/
+	fill( value: ComplexLike, start?: number, end?: number ): Complex64Array;
+
+	/**
+	* Returns a new array containing the elements of an array which pass a test implemented by a predicate function.
+	*
+	* @param predicate - test function
+	* @param thisArg - execution context
+	* @returns new array containing elements which pass a test implemented by a predicate function
+	*
+	* @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 out = arr.filter( predicate );
+	* // returns <Complex64Array>
+	*
+	* var len = out.length;
+	* // returns 1
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* 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 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.find( predicate );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* var im = imagf( z );
+	* // 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 );
+	*
+	* 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>
+	*
+	* var re = realf( z );
+	* // returns 3.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.
 	*
@@ -233,6 +674,192 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	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;
+
+	/**
+	* 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.
 	*
@@ -265,8 +892,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @throws target array lacks sufficient storage to accommodate source values
 	*
 	* @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 arr = new Complex64Array( 10 );
 	*
@@ -290,7 +917,271 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* im = imagf( z );
 	* // returns -1.0
 	*/
-	set( value: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | ComplexLike, i?: number ): void; // tslint:disable-line:max-line-length
+	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
+	*/
+	with( index: number, value: ComplexLike ): Complex64Array;
 }
 
 /**
@@ -335,7 +1226,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 +1236,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 +1246,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 +1255,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 +1295,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 +1305,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 +1315,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 +1324,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 +1363,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 +1372,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 +1386,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 +1442,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 +1452,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 +1462,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 );