@stdlib/array-complex64 0.2.0 → 0.3.0

package/lib/main.js

@@ -28,6 +28,7 @@ var isCollection = require( '@stdlib/assert-is-collection' );
 var isArrayBuffer = require( '@stdlib/assert-is-arraybuffer' );
 var isObject = require( '@stdlib/assert-is-object' );
 var isArray = require( '@stdlib/assert-is-array' );
+var isStringArray = require( '@stdlib/assert-is-string-array' ).primitives;
 var isString = require( '@stdlib/assert-is-string' ).isPrimitive;
 var isFunction = require( '@stdlib/assert-is-function' );
 var isComplexLike = require( '@stdlib/assert-is-complex-like' );
@@ -40,10 +41,10 @@ var ITERATOR_SYMBOL = require( '@stdlib/symbol-iterator' );
 var setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
 var setReadOnlyAccessor = require( '@stdlib/utils-define-nonenumerable-read-only-accessor' );
 var Float32Array = require( '@stdlib/array-float32' );
-var Complex64 = require( '@stdlib/complex-float32' );
+var Complex64 = require( '@stdlib/complex-float32-ctor' );
 var format = require( '@stdlib/string-format' );
-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 floor = require( '@stdlib/math-base-special-floor' );
 var reinterpret64 = require( '@stdlib/strided-base-reinterpret-complex64' );
 var reinterpret128 = require( '@stdlib/strided-base-reinterpret-complex128' );
@@ -354,7 +355,7 @@ setReadOnly( Complex64Array, 'name', 'Complex64Array' );
 * // 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>
@@ -363,9 +364,9 @@ setReadOnly( Complex64Array, 'name', 'Complex64Array' );
 * // 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 );
@@ -550,8 +551,8 @@ setReadOnly( Complex64Array, 'of', function of() {
 *
 * @example
 * var arr = new Complex64Array( 10 );
-* 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 z = arr.at( 0 );
 * // returns <Complex64>
@@ -690,9 +691,9 @@ setReadOnly( Complex64Array.prototype, 'BYTES_PER_ELEMENT', Complex64Array.BYTES
 * @returns {Complex64Array} 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 );
 *
@@ -737,7 +738,7 @@ setReadOnly( Complex64Array.prototype, 'copyWithin', function copyWithin( target
 * @returns {Iterator} iterator
 *
 * @example
-* var Complex64 = require( '@stdlib/complex-float32' );
+* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 *
 * var arr = [
 *     new Complex64( 1.0, 1.0 ),
@@ -763,23 +764,21 @@ setReadOnly( Complex64Array.prototype, 'copyWithin', function copyWithin( target
 * // returns true
 */
 setReadOnly( Complex64Array.prototype, 'entries', function entries() {
-	var buffer;
 	var self;
 	var iter;
 	var len;
+	var buf;
 	var FLG;
 	var i;
-	var j;
 	if ( !isComplexArray( this ) ) {
 		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
 	}
 	self = this;
-	buffer = this._buffer;
+	buf = this._buffer;
 	len = this._length;
 
-	// Initialize the iteration indices:
+	// Initialize an iteration index:
 	i = -1;
-	j = -2;
 
 	// Create an iterator protocol-compliant object:
 	iter = {};
@@ -798,17 +797,14 @@ setReadOnly( Complex64Array.prototype, 'entries', function entries() {
 	* @returns {Object} iterator protocol-compliant object
 	*/
 	function next() {
-		var z;
 		i += 1;
 		if ( FLG || i >= len ) {
 			return {
 				'done': true
 			};
 		}
-		j += 2;
-		z = new Complex64( buffer[ j ], buffer[ j+1 ] );
 		return {
-			'value': [ i, z ],
+			'value': [ i, getComplex64( buf, i ) ],
 			'done': false
 		};
 	}
@@ -857,8 +853,8 @@ setReadOnly( Complex64Array.prototype, 'entries', function entries() {
 * @returns {boolean} 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 ) );
@@ -904,10 +900,11 @@ setReadOnly( Complex64Array.prototype, 'every', function every( predicate, thisA
 * @throws {TypeError} first argument must be a complex number
 * @throws {TypeError} second argument must be an integer
 * @throws {TypeError} third argument must be an integer
+* @returns {Complex64Array} modified 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 );
 *
@@ -922,7 +919,7 @@ setReadOnly( Complex64Array.prototype, 'every', function every( predicate, thisA
 * var im = imagf( z );
 * // returns 1.0
 *
-* z = arr.get( 1 );
+* z = arr.get( 2 );
 * // returns <Complex64>
 *
 * re = realf( z );
@@ -999,8 +996,8 @@ setReadOnly( Complex64Array.prototype, 'fill', function fill( value, start, end
 * @returns {Complex64Array} complex number 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' );
 *
 * function predicate( v ) {
 *     return ( realf( v ) === imagf( v ) );
@@ -1062,9 +1059,9 @@ setReadOnly( Complex64Array.prototype, 'filter', function filter( predicate, thi
 * @returns {(Complex64|void)} 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 ) );
@@ -1117,9 +1114,9 @@ setReadOnly( Complex64Array.prototype, 'find', function find( predicate, thisArg
 * @returns {integer} 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 ) );
@@ -1167,9 +1164,9 @@ setReadOnly( Complex64Array.prototype, 'findIndex', function findIndex( predicat
 * @returns {(Complex64|void)} 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 ) );
@@ -1222,9 +1219,9 @@ setReadOnly( Complex64Array.prototype, 'findLast', function findLast( predicate,
 * @returns {integer} 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 ) );
@@ -1271,7 +1268,7 @@ setReadOnly( Complex64Array.prototype, 'findLastIndex', function findLastIndex(
 * @throws {TypeError} first argument must be a function
 *
 * @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() );
@@ -1315,8 +1312,8 @@ setReadOnly( Complex64Array.prototype, 'forEach', function forEach( fcn, thisArg
 *
 * @example
 * var arr = new Complex64Array( 10 );
-* 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 z = arr.get( 0 );
 * // returns <Complex64>
@@ -1368,7 +1365,7 @@ setReadOnly( Complex64Array.prototype, 'get', function get( idx ) {
 * @returns {boolean} boolean indicating whether an array includes a provided value
 *
 * @example
-* var Complex64 = require( '@stdlib/complex-float32' );
+* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 *
 * var arr = new Complex64Array( 5 );
 *
@@ -1438,7 +1435,7 @@ setReadOnly( Complex64Array.prototype, 'includes', function includes( searchElem
 * @returns {integer} index or -1
 *
 * @example
-* var Complex64 = require( '@stdlib/complex-float32' );
+* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 *
 * var arr = new Complex64Array( 10 );
 *
@@ -1540,6 +1537,107 @@ setReadOnly( Complex64Array.prototype, 'join', function join( separator ) {
 	return out.join( sep );
 });
 
+/**
+* Returns an iterator for iterating over each index key in a typed array.
+*
+* @name keys
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @throws {TypeError} `this` must be a complex number array
+* @returns {Iterator} 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
+*/
+setReadOnly( Complex64Array.prototype, 'keys', function keys() {
+	var self;
+	var iter;
+	var len;
+	var FLG;
+	var i;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	self = this;
+	len = this._length;
+
+	// Initialize an iteration index:
+	i = -1;
+
+	// Create an iterator protocol-compliant object:
+	iter = {};
+	setReadOnly( iter, 'next', next );
+	setReadOnly( iter, 'return', end );
+
+	if ( ITERATOR_SYMBOL ) {
+		setReadOnly( iter, ITERATOR_SYMBOL, factory );
+	}
+	return iter;
+
+	/**
+	* Returns an iterator protocol-compliant object containing the next iterated value.
+	*
+	* @private
+	* @returns {Object} iterator protocol-compliant object
+	*/
+	function next() {
+		i += 1;
+		if ( FLG || i >= len ) {
+			return {
+				'done': true
+			};
+		}
+		return {
+			'value': i,
+			'done': false
+		};
+	}
+
+	/**
+	* Finishes an iterator.
+	*
+	* @private
+	* @param {*} [value] - value to return
+	* @returns {Object} iterator protocol-compliant object
+	*/
+	function end( value ) {
+		FLG = true;
+		if ( arguments.length ) {
+			return {
+				'value': value,
+				'done': true
+			};
+		}
+		return {
+			'done': true
+		};
+	}
+
+	/**
+	* Returns a new iterator.
+	*
+	* @private
+	* @returns {Iterator} iterator
+	*/
+	function factory() {
+		return self.keys();
+	}
+});
+
 /**
 * Returns the last index at which a given element can be found.
 *
@@ -1554,7 +1652,7 @@ setReadOnly( Complex64Array.prototype, 'join', function join( separator ) {
 * @returns {integer} index or -1
 *
 * @example
-* var Complex64 = require( '@stdlib/complex-float32' );
+* var Complex64 = require( '@stdlib/complex-float32-ctor' );
 *
 * var arr = new Complex64Array( 5 );
 *
@@ -1643,9 +1741,9 @@ setReadOnlyAccessor( Complex64Array.prototype, 'length', function get() {
 * @returns {Complex64Array} complex number 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' );
 *
 * function scale( v, i ) {
 *     return new Complex64( 2.0*realf( v ), 2.0*imagf( v ) );
@@ -1699,6 +1797,136 @@ setReadOnly( Complex64Array.prototype, 'map', function map( fcn, thisArg ) {
 	return out;
 });
 
+/**
+* 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.
+*
+* @name reduce
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {Function} reducer - callback function
+* @param {*} [initialValue] - initial value
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a function
+* @throws {Error} if not provided an initial value, the array must have at least one element
+* @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
+*/
+setReadOnly( Complex64Array.prototype, 'reduce', function reduce( reducer, initialValue ) {
+	var buf;
+	var acc;
+	var len;
+	var v;
+	var i;
+
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isFunction( reducer ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', reducer ) );
+	}
+	buf = this._buffer;
+	len = this._length;
+	if ( arguments.length > 1 ) {
+		acc = initialValue;
+		i = 0;
+	} else {
+		if ( len === 0 ) {
+			throw new Error( 'invalid operation. If not provided an initial value, an array must contain at least one element.' );
+		}
+		acc = getComplex64( buf, 0 );
+		i = 1;
+	}
+	for ( ; i < len; i++ ) {
+		v = getComplex64( buf, i );
+		acc = reducer( acc, v, i, this );
+	}
+	return acc;
+});
+
+/**
+* Applies a provided callback function to each element of the array, in reverse order, passing in the return value from the calculation on the preceding element and returning the accumulated result upon completion.
+*
+* @name reduceRight
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {Function} reducer - callback function
+* @param {*} [initialValue] - initial value
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a function
+* @throws {Error} if not provided an initial value, the array must have at least one element
+* @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
+*/
+setReadOnly( Complex64Array.prototype, 'reduceRight', function reduceRight( reducer, initialValue ) {
+	var buf;
+	var acc;
+	var len;
+	var v;
+	var i;
+
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isFunction( reducer ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', reducer ) );
+	}
+	buf = this._buffer;
+	len = this._length;
+	if ( arguments.length > 1 ) {
+		acc = initialValue;
+		i = len-1;
+	} else {
+		if ( len === 0 ) {
+			throw new Error( 'invalid operation. If not provided an initial value, an array must contain at least one element.' );
+		}
+		acc = getComplex64( buf, len-1 );
+		i = len-2;
+	}
+	for ( ; i >= 0; i-- ) {
+		v = getComplex64( buf, i );
+		acc = reducer( acc, v, i, this );
+	}
+	return acc;
+});
+
 /**
 * Reverses an array in-place.
 *
@@ -1709,8 +1937,8 @@ setReadOnly( Complex64Array.prototype, 'map', function map( fcn, thisArg ) {
 * @returns {Complex64Array} 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 );
 *
@@ -1810,8 +2038,8 @@ setReadOnly( Complex64Array.prototype, 'reverse', function reverse() {
 * @returns {void}
 *
 * @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 );
 *
@@ -1978,8 +2206,8 @@ setReadOnly( Complex64Array.prototype, 'set', function set( value ) {
 * @returns {Complex64Array} complex number 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 );
 *
@@ -2107,8 +2335,8 @@ setReadOnly( Complex64Array.prototype, 'slice', function slice( start, end ) {
 * @returns {boolean} 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 ) );
@@ -2141,6 +2369,108 @@ setReadOnly( Complex64Array.prototype, 'some', function some( predicate, thisArg
 	return false;
 });
 
+/**
+* Sorts an array in-place.
+*
+* @name sort
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {Function} compareFcn - comparison function
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a function
+* @returns {Complex64Array} 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
+*/
+setReadOnly( Complex64Array.prototype, 'sort', function sort( compareFcn ) {
+	var tmp;
+	var buf;
+	var len;
+	var i;
+	var j;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isFunction( compareFcn ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', compareFcn ) );
+	}
+	buf = this._buffer;
+	len = this._length;
+	tmp = [];
+	for ( i = 0; i < len; i++ ) {
+		tmp.push( getComplex64( buf, i ) );
+	}
+	tmp.sort( compareFcn );
+	for ( i = 0; i < len; i++ ) {
+		j = 2 * i;
+		buf[ j ] = realf( tmp[i] );
+		buf[ j+1 ] = imagf( tmp[i] );
+	}
+	return this;
+});
+
 /**
 * Creates a new typed array view over the same underlying `ArrayBuffer` and with the same underlying data type as the host array.
 *
@@ -2155,8 +2485,8 @@ setReadOnly( Complex64Array.prototype, 'some', function some( predicate, thisArg
 * @returns {Complex64Array} 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 );
 *
@@ -2265,6 +2595,59 @@ setReadOnly( Complex64Array.prototype, 'subarray', function subarray( begin, end
 	return new this.constructor( buf.buffer, offset, ( len < 0 ) ? 0 : len );
 });
 
+/**
+* Serializes an array as a locale-specific string.
+*
+* @name toLocaleString
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {(string|Array<string>)} [locales] - locale identifier(s)
+* @param {Object} [options] - configuration options
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a string or an array of strings
+* @throws {TypeError} options argument must be an object
+* @returns {string} string representation
+*
+* @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'
+*/
+setReadOnly( Complex64Array.prototype, 'toLocaleString', function toLocaleString( locales, options ) {
+	var opts;
+	var loc;
+	var out;
+	var buf;
+	var i;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( arguments.length === 0 ) {
+		loc = [];
+	} else if ( isString( locales ) || isStringArray( locales ) ) {
+		loc = locales;
+	} else {
+		throw new TypeError( format( 'invalid argument. First argument must be a string or an array of strings. Value: `%s`.', locales ) );
+	}
+	if ( arguments.length < 2 ) {
+		opts = {};
+	} else if ( isObject( options ) ) {
+		opts = options;
+	} else {
+		throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+	}
+	buf = this._buffer;
+	out = [];
+	for ( i = 0; i < this._length; i++ ) {
+		out.push( getComplex64( buf, i ).toLocaleString( loc, opts ) );
+	}
+	return out.join( ',' );
+});
+
 /**
 * Returns a new typed array containing the elements in reversed order.
 *
@@ -2275,8 +2658,8 @@ setReadOnly( Complex64Array.prototype, 'subarray', function subarray( begin, end
 * @returns {Complex64Array} 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 );
 *
@@ -2336,6 +2719,102 @@ setReadOnly( Complex64Array.prototype, 'toReversed', function toReversed() {
 	return out;
 });
 
+/**
+* Returns a new typed array containing the elements in sorted order.
+*
+* @name toSorted
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {Function} compareFcn - comparison function
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a function
+* @returns {Complex64Array} 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
+*/
+setReadOnly( Complex64Array.prototype, 'toSorted', function toSorted( compareFcn ) {
+	var tmp;
+	var buf;
+	var len;
+	var i;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isFunction( compareFcn ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', compareFcn ) );
+	}
+	buf = this._buffer;
+	len = this._length;
+	tmp = [];
+	for ( i = 0; i < len; i++ ) {
+		tmp.push( getComplex64( buf, i ) );
+	}
+	tmp.sort( compareFcn );
+	return new Complex64Array( tmp );
+});
+
 /**
 * Serializes an array as a string.
 *
@@ -2369,6 +2848,123 @@ setReadOnly( Complex64Array.prototype, 'toString', function toString() {
 	return out.join( ',' );
 });
 
+/**
+* Returns an iterator for iterating over each value in a typed array.
+*
+* @name values
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @throws {TypeError} `this` must be a complex number array
+* @returns {Iterator} 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
+*/
+setReadOnly( Complex64Array.prototype, 'values', function values() {
+	var iter;
+	var self;
+	var len;
+	var FLG;
+	var buf;
+	var i;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	self = this;
+	buf = this._buffer;
+	len = this._length;
+
+	// Initialize an iteration index:
+	i = -1;
+
+	// Create an iterator protocol-compliant object:
+	iter = {};
+	setReadOnly( iter, 'next', next );
+	setReadOnly( iter, 'return', end );
+
+	if ( ITERATOR_SYMBOL ) {
+		setReadOnly( iter, ITERATOR_SYMBOL, factory );
+	}
+	return iter;
+
+	/**
+	* Returns an iterator protocol-compliant object containing the next iterated value.
+	*
+	* @private
+	* @returns {Object} iterator protocol-compliant object
+	*/
+	function next() {
+		i += 1;
+		if ( FLG || i >= len ) {
+			return {
+				'done': true
+			};
+		}
+		return {
+			'value': getComplex64( buf, i ),
+			'done': false
+		};
+	}
+
+	/**
+	* Finishes an iterator.
+	*
+	* @private
+	* @param {*} [value] - value to return
+	* @returns {Object} iterator protocol-compliant object
+	*/
+	function end( value ) {
+		FLG = true;
+		if ( arguments.length ) {
+			return {
+				'value': value,
+				'done': true
+			};
+		}
+		return {
+			'done': true
+		};
+	}
+
+	/**
+	* Returns a new iterator.
+	*
+	* @private
+	* @returns {Iterator} iterator
+	*/
+	function factory() {
+		return self.values();
+	}
+});
+
 /**
 * Returns a new typed array with the element at a provided index replaced with a provided value.
 *
@@ -2384,9 +2980,9 @@ setReadOnly( Complex64Array.prototype, 'toString', function toString() {
 * @returns {Complex64Array} new 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 );
 *