@stdlib/array-complex64 0.2.0 → 0.3.0

package/docs/types/index.d.ts

@@ -22,7 +22,7 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { Iterator as Iter, IterableIterator } from '@stdlib/types/iter';
+import { Iterator as Iter, IterableIterator, TypedIterator } from '@stdlib/types/iter';
 import { ArrayLike, RealOrComplexTypedArray, Complex64Array as Complex64ArrayInterface } from '@stdlib/types/array';
 import { ComplexLike, Complex64 } from '@stdlib/types/complex';
 import ArrayBuffer = require( '@stdlib/array-buffer' );
@@ -30,6 +30,16 @@ import ArrayBuffer = require( '@stdlib/array-buffer' );
 // Define a union type representing both iterable and non-iterable iterators:
 type Iterator = Iter | IterableIterator;
 
+/**
+* Locale-specific configuration options.
+*/
+interface LocaleOptions<T = unknown> {
+	/**
+	* Configuration property.
+	*/
+	[ key: string | symbol | number ]: T | undefined;
+};
+
 /**
 * Callback invoked for each element in a source object.
 *
@@ -195,6 +205,69 @@ type TernaryMapFcn<U> = ( this: U, value: Complex64, index: number, arr: Complex
 */
 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>;
+
+/**
+* Comparator function.
+*
+* @param a - first value for comparison
+* @param b - second value for comparison
+* @returns number indicating comparison result
+*/
+type CompareFcn = ( a: Complex64, b: Complex64 ) => number;
+
 /**
 * Class for creating a 64-bit complex number array.
 */
@@ -348,9 +421,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-ctor' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 4 );
 	*
@@ -380,7 +453,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns iterator
 	*
 	* @example
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* var arr = [
 	*     new Complex64( 1.0, 1.0 ),
@@ -405,7 +478,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* var bool = it.next().done;
 	* // returns true
 	*/
-	entries(): Iterator;
+	entries(): TypedIterator<[number, Complex64]>;
 
 	/**
 	* Tests whether all elements in an array pass a test implemented by a predicate function.
@@ -415,8 +488,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns boolean indicating whether all elements pass a test
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -442,8 +515,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns modified typed array
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 3 );
 	*
@@ -477,8 +550,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @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' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -515,9 +588,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns array element or undefined
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -548,9 +621,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns index or -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-ctor' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -575,9 +648,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns array element or undefined
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -608,9 +681,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns index or -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-ctor' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -635,7 +708,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns undefined
 	*
 	* @example
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* function log( v, i ) {
 	*     console.log( '%s: %s', i, v.toString() );
@@ -748,6 +821,30 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	join( separator?: string ): string;
 
+	/**
+	* Returns an iterator for iterating over each index key in a typed array.
+	*
+	* @returns iterator
+	*
+	* @example
+	* var arr = new Complex64Array( 2 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	*
+	* var iter = arr.keys();
+	*
+	* var v = iter.next().value;
+	* // returns 0
+	*
+	* v = iter.next().value;
+	* // returns 1
+	*
+	* var bool = iter.next().done;
+	* // returns true
+	*/
+	keys(): TypedIterator<number>;
+
 	/**
 	* Returns the last index at which a given element can be found.
 	*
@@ -756,7 +853,7 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns index or -1
 	*
 	* @example
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* var arr = new Complex64Array( 5 );
 	*
@@ -785,9 +882,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @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' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function scale( v, i ) {
 	*     return new Complex64( 2.0*realf( v ), 2.0*imagf( v ) );
@@ -813,14 +910,72 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	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-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var caddf = require( '@stdlib/complex-float32-base-add' );
+	*
+	* 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;
+
+	/**
+	* Applies a provided callback function to each element of the array, in reverse order, passing in the return value from the calculation on the following 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-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var caddf = require( '@stdlib/complex-float32-base-add' );
+	*
+	* 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.reduceRight( caddf );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 6.0
+	*
+	* var im = imagf( z );
+	* // returns 6.0
+	*/
+	reduceRight<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 realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 3 );
 	*
@@ -892,8 +1047,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-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 10 );
 	*
@@ -928,8 +1083,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns output array
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 5 );
 	*
@@ -997,8 +1152,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns boolean indicating whether at least one element passes a test
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function predicate( v ) {
 	*     return ( realf( v ) === imagf( v ) );
@@ -1015,6 +1170,78 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	some<U = unknown>( predicate: Predicate<U>, thisArg?: ThisParameterType<Predicate<U>> ): boolean;
 
+	/**
+	* Sorts an array in-place.
+	*
+	* @param compareFcn - comparison function
+	* @returns sorted array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	*
+	* function compare( a, b ) {
+	*     var re1;
+	*     var re2;
+	*     var im1;
+	*     var im2;
+	*     re1 = realf( a );
+	*     re2 = realf( b );
+	*     if ( re1 < re2 ) {
+	*         return -1;
+	*     }
+	*     if ( re1 > re2 ) {
+	*         return 1;
+	*     }
+	*     im1 = imagf( a );
+	*     im2 = imagf( b );
+	*     if ( im1 < im2 ) {
+	*         return -1;
+	*     }
+	*     if ( im1 > im2 ) {
+	*         return 1;
+	*     }
+	*     return 0;
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 3.0, -3.0 ], 0 );
+	* arr.set( [ 1.0, -1.0 ], 1 );
+	* arr.set( [ 2.0, -2.0 ], 2 );
+	*
+	* var out = arr.sort( compare );
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* var im = imagf( z );
+	* // returns -1.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 3.0
+	*
+	* im = imagf( z );
+	* // returns -3.0
+	*/
+	sort( compareFcn: CompareFcn ): Complex64Array;
+
 	/**
 	* Creates a new typed array view over the same underlying `ArrayBuffer` and with the same underlying data type as the host array.
 	*
@@ -1024,8 +1251,8 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns subarray
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 5 );
 	*
@@ -1085,14 +1312,32 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	subarray( begin?: number, end?: number ): Complex64Array;
 
+	/**
+	* Serializes an array as a locale-specific string.
+	*
+	* @param locales - locale identifier(s)
+	* @param options - configuration options
+	* @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.toLocaleString();
+	* // returns '1 + 1i,2 + 2i'
+	*/
+	toLocaleString( locales?: string | Array<string>, options?: LocaleOptions ): string;
+
 	/**
 	* 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 realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* var arr = new Complex64Array( 3 );
 	*
@@ -1132,6 +1377,78 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	toReversed(): Complex64Array;
 
+	/**
+	* Returns a new typed array containing the elements in sorted order.
+	*
+	* @param compareFcn - comparison function
+	* @returns sorted array
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	*
+	* function compare( a, b ) {
+	*     var re1;
+	*     var re2;
+	*     var im1;
+	*     var im2;
+	*     re1 = realf( a );
+	*     re2 = realf( b );
+	*     if ( re1 < re2 ) {
+	*         return -1;
+	*     }
+	*     if ( re1 > re2 ) {
+	*         return 1;
+	*     }
+	*     im1 = imagf( a );
+	*     im2 = imagf( b );
+	*     if ( im1 < im2 ) {
+	*         return -1;
+	*     }
+	*     if ( im1 > im2 ) {
+	*         return 1;
+	*     }
+	*     return 0;
+	* }
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 3.0, -3.0 ], 0 );
+	* arr.set( [ 1.0, -1.0 ], 1 );
+	* arr.set( [ 2.0, -2.0 ], 2 );
+	*
+	* var out = arr.toSorted( compare );
+	* // returns <Complex64Array>
+	*
+	* var z = out.get( 0 );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 1.0
+	*
+	* var im = imagf( z );
+	* // returns -1.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 3.0
+	*
+	* im = imagf( z );
+	* // returns -3.0
+	*/
+	toSorted( compareFcn: CompareFcn ): Complex64Array;
+
 	/**
 	* Serializes an array as a string.
 	*
@@ -1148,6 +1465,44 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	toString(): string;
 
+	/**
+	* Returns an iterator for iterating over each value in a typed array.
+	*
+	* @returns iterator
+	*
+	* @example
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var arr = new Complex64Array( 2 );
+	*
+	* arr.set( [ 1.0, -1.0 ], 0 );
+	* arr.set( [ 2.0, -2.0 ], 1 );
+	*
+	* var iter = arr.values();
+	*
+	* var v = iter.next().value;
+	* // returns <Complex64>
+	*
+	* var re = realf( v );
+	* // returns 1.0
+	*
+	* var im = imagf( v );
+	* // returns -1.0
+	*
+	* v = iter.next().value;
+	* // returns <Complex64>
+	*
+	* re = realf( v );
+	* // returns 2.0
+	*
+	* im = imagf( v );
+	* // returns -2.0
+	*
+	* var bool = iter.next().done;
+	* // returns true
+	*/
+	values(): TypedIterator<Complex64>;
+
 	/**
 	* Returns a new typed array with the element at a provided index replaced with a provided value.
 	*
@@ -1159,9 +1514,9 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	* @returns modified typed array
 	*
 	* @example
-	* var realf = require( '@stdlib/complex-realf' );
-	* var imagf = require( '@stdlib/complex-imagf' );
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* var arr = new Complex64Array( 3 );
 	*
@@ -1363,7 +1718,7 @@ interface Complex64ArrayConstructor {
 	* // returns 1
 	*
 	* @example
-	* var Complex64 = require( '@stdlib/complex-float32' );
+	* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 	*
 	* var arr = Complex64Array.from( [ new Complex64( 1.0, 1.0 ) ] );
 	* // returns <Complex64Array>
@@ -1372,9 +1727,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-ctor' );
+	* var realf = require( '@stdlib/complex-float32-real' );
+	* var imagf = require( '@stdlib/complex-float32-imag' );
 	*
 	* function clbk( v ) {
 	*     return new Complex64( realf(v)*2.0, imagf(v)*2.0 );
@@ -1386,12 +1741,12 @@ interface Complex64ArrayConstructor {
 	* var len = arr.length;
 	* // returns 1
 	*/
-	from( src: ArrayLike<number | ComplexLike> | RealOrComplexTypedArray | Iterable<number | ComplexLike>, clbk?: FromCallback<U>, thisArg?: ThisParameterType<FromCallback<U>> ): Complex64Array;
+	from<U = unknown>( 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.
 	*
-	* @param  element - array elements
+	* @param elements - array elements
 	* @returns 64-bit complex number array
 	*
 	* @example

package/lib/from_array.js

@@ -21,8 +21,8 @@
 // MODULES //
 
 var isComplexLike = require( '@stdlib/assert-is-complex-like' );
-var realf = require( '@stdlib/complex-realf' );
-var imagf = require( '@stdlib/complex-imagf' );
+var realf = require( '@stdlib/complex-float32-real' );
+var imagf = require( '@stdlib/complex-float32-imag' );
 
 
 // MAIN //

package/lib/from_iterator.js

@@ -22,8 +22,8 @@
 
 var isArrayLikeObject = require( '@stdlib/assert-is-array-like-object' );
 var isComplexLike = require( '@stdlib/assert-is-complex-like' );
-var realf = require( '@stdlib/complex-realf' );
-var imagf = require( '@stdlib/complex-imagf' );
+var realf = require( '@stdlib/complex-float32-real' );
+var imagf = require( '@stdlib/complex-float32-imag' );
 var format = require( '@stdlib/string-format' );