@stdlib/array-complex64 0.0.5 → 0.1.0

package/lib/main.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-restricted-syntax, max-lines */
+/* eslint-disable no-restricted-syntax, max-lines, no-invalid-this */
 
 /**
 * @license Apache-2.0
@@ -34,11 +34,17 @@ var isEven = require( '@stdlib/math-base-assert-is-even' );
 var isInteger = require( '@stdlib/math-base-assert-is-integer' );
 var hasIteratorSymbolSupport = require( '@stdlib/assert-has-iterator-symbol-support' );
 var ITERATOR_SYMBOL = require( '@stdlib/symbol-iterator' );
-var defineProperty = require( '@stdlib/utils-define-property' );
+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 real = require( '@stdlib/complex-real' );
-var imag = require( '@stdlib/complex-imag' );
+var format = require( '@stdlib/string-format' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+var reinterpret64 = require( '@stdlib/strided-base-reinterpret-complex64' );
+var reinterpret128 = require( '@stdlib/strided-base-reinterpret-complex128' );
+var getter = require( '@stdlib/array-base-getter' );
+var accessorGetter = require( '@stdlib/array-base-accessor-getter' );
 var fromIterator = require( './from_iterator.js' );
 var fromIteratorMap = require( './from_iterator_map.js' );
 var fromArray = require( './from_array.js' );
@@ -93,6 +99,38 @@ function isComplexArrayConstructor( value ) {
 	);
 }
 
+/**
+* Returns a boolean indicating if a value is a `Complex64Array`.
+*
+* @private
+* @param {*} value - value to test
+* @returns {boolean} boolean indicating if a value is a `Complex64Array`
+*/
+function isComplex64Array( value ) {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		value.constructor.name === 'Complex64Array' &&
+		value.BYTES_PER_ELEMENT === BYTES_PER_ELEMENT
+	);
+}
+
+/**
+* Returns a boolean indicating if a value is a `Complex128Array`.
+*
+* @private
+* @param {*} value - value to test
+* @returns {boolean} boolean indicating if a value is a `Complex128Array`
+*/
+function isComplex128Array( value ) {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		value.constructor.name === 'Complex128Array' &&
+		value.BYTES_PER_ELEMENT === BYTES_PER_ELEMENT*2
+	);
+}
+
 
 // MAIN //
 
@@ -100,7 +138,7 @@ function isComplexArrayConstructor( value ) {
 * 64-bit complex number array constructor.
 *
 * @constructor
-* @param {(NonNegativeInteger|TypedArray|ArrayLikeObject|ArrayBuffer|Iterable)} [arg] - length, typed array, array-like object, or buffer
+* @param {(NonNegativeInteger|Collection|ArrayBuffer|Iterable)} [arg] - length, typed array, array-like object, buffer, or an iterable
 * @param {NonNegativeInteger} [byteOffset=0] - byte offset
 * @param {NonNegativeInteger} [length] - view length
 * @throws {RangeError} ArrayBuffer byte length must be a multiple of `8`
@@ -199,34 +237,38 @@ function Complex64Array() {
 				if ( buf === null ) {
 					// We failed and we are now forced to allocate a new array :-(
 					if ( !isEven( len ) ) {
-						throw new RangeError( 'invalid argument. Array-like object input arguments must have a length which is a multiple of two. Length: `'+len+'`.' );
+						throw new RangeError( format( 'invalid argument. Array-like object arguments must have a length which is a multiple of two. Length: `%u`.', len ) );
 					}
 					// We failed, so fall back to directly setting values...
 					buf = new Float32Array( arguments[0] );
 				}
 			} else {
-				if ( !isEven( len ) ) {
-					throw new RangeError( 'invalid argument. Array-like object and typed array input arguments must have a length which is a multiple of two. Length: `'+len+'`.' );
+				if ( isComplex64Array( buf ) ) {
+					buf = reinterpret64( buf, 0 );
+				} else if ( isComplex128Array( buf ) ) {
+					buf = reinterpret128( buf, 0 );
+				} else if ( !isEven( len ) ) {
+					throw new RangeError( format( 'invalid argument. Array-like object and typed array arguments must have a length which is a multiple of two. Length: `%u`.', len ) );
 				}
 				buf = new Float32Array( buf );
 			}
 		} else if ( isArrayBuffer( arguments[0] ) ) {
 			buf = arguments[ 0 ];
 			if ( !isInteger( buf.byteLength/BYTES_PER_ELEMENT ) ) {
-				throw new RangeError( 'invalid argument. ArrayBuffer byte length must be a multiple of '+BYTES_PER_ELEMENT+'. Byte length: `'+buf.byteLength+'`.' );
+				throw new RangeError( format( 'invalid argument. ArrayBuffer byte length must be a multiple of %u. Byte length: `%u`.', BYTES_PER_ELEMENT, buf.byteLength ) );
 			}
 			buf = new Float32Array( buf );
 		} else if ( isObject( arguments[0] ) ) {
 			buf = arguments[ 0 ];
 			if ( HAS_ITERATOR_SYMBOL === false ) {
-				throw new TypeError( 'invalid argument. Environment lacks Symbol.iterator support. Must provide a length, ArrayBuffer, typed array, or array-like object. Value: `'+buf+'`.' );
+				throw new TypeError( format( 'invalid argument. Environment lacks Symbol.iterator support. Must provide a length, ArrayBuffer, typed array, or array-like object. Value: `%s`.', buf ) );
 			}
 			if ( !isFunction( buf[ ITERATOR_SYMBOL ] ) ) {
-				throw new TypeError( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `'+buf+'`.' );
+				throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', buf ) );
 			}
 			buf = buf[ ITERATOR_SYMBOL ]();
 			if ( !isFunction( buf.next ) ) {
-				throw new TypeError( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable.' );
+				throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', buf ) );
 			}
 			buf = fromIterator( buf );
 			if ( buf instanceof Error ) {
@@ -234,49 +276,39 @@ function Complex64Array() {
 			}
 			buf = new Float32Array( buf );
 		} else {
-			throw new TypeError( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `'+arguments[0]+'`.' );
+			throw new TypeError( format( 'invalid argument. Must provide a length, ArrayBuffer, typed array, array-like object, or an iterable. Value: `%s`.', arguments[0] ) );
 		}
 	} else {
 		buf = arguments[ 0 ];
 		if ( !isArrayBuffer( buf ) ) {
-			throw new TypeError( 'invalid argument. First argument must be an array buffer. Value: `'+buf+'`.' );
+			throw new TypeError( format( 'invalid argument. First argument must be an ArrayBuffer. Value: `%s`.', buf ) );
 		}
 		byteOffset = arguments[ 1 ];
 		if ( !isNonNegativeInteger( byteOffset ) ) {
-			throw new TypeError( 'invalid argument. Byte offset must be a nonnegative integer. Value: `'+byteOffset+'`.' );
+			throw new TypeError( format( 'invalid argument. Byte offset must be a nonnegative integer. Value: `%s`.', byteOffset ) );
 		}
 		if ( !isInteger( byteOffset/BYTES_PER_ELEMENT ) ) {
-			throw new RangeError( 'invalid argument. Byte offset must be a multiple of '+BYTES_PER_ELEMENT+'. Value: `'+byteOffset+'`.' );
+			throw new RangeError( format( 'invalid argument. Byte offset must be a multiple of %u. Value: `%u`.', BYTES_PER_ELEMENT, byteOffset ) );
 		}
 		if ( nargs === 2 ) {
 			len = buf.byteLength - byteOffset;
 			if ( !isInteger( len/BYTES_PER_ELEMENT ) ) {
-				throw new RangeError( 'invalid arguments. ArrayBuffer view byte length must be a multiple of '+BYTES_PER_ELEMENT+'. View byte length: `'+len+'`.' );
+				throw new RangeError( format( 'invalid arguments. ArrayBuffer view byte length must be a multiple of %u. View byte length: `%u`.', BYTES_PER_ELEMENT, len ) );
 			}
 			buf = new Float32Array( buf, byteOffset );
 		} else {
 			len = arguments[ 2 ];
 			if ( !isNonNegativeInteger( len ) ) {
-				throw new TypeError( 'invalid argument. Length must be a nonnegative integer. Value: `'+len+'`.' );
+				throw new TypeError( format( 'invalid argument. Length must be a nonnegative integer. Value: `%s`.', len ) );
 			}
 			if ( (len*BYTES_PER_ELEMENT) > (buf.byteLength-byteOffset) ) {
-				throw new RangeError( 'invalid arguments. ArrayBuffer has insufficient capacity. Either decrease the array length or provide a bigger buffer. Minimum capacity: `'+(len*BYTES_PER_ELEMENT)+'`.' );
+				throw new RangeError( format( 'invalid arguments. ArrayBuffer has insufficient capacity. Either decrease the array length or provide a bigger buffer. Minimum capacity: `%u`.', len*BYTES_PER_ELEMENT ) );
 			}
 			buf = new Float32Array( buf, byteOffset, len*2 );
 		}
 	}
-	defineProperty( this, '_buffer', {
-		'configurable': false,
-		'enumerable': false,
-		'writable': false,
-		'value': buf
-	});
-	defineProperty( this, '_length', {
-		'configurable': false,
-		'enumerable': false,
-		'writable': false,
-		'value': buf.length / 2
-	});
+	setReadOnly( this, '_buffer', buf );
+	setReadOnly( this, '_length', buf.length/2 );
 
 	return this;
 }
@@ -286,6 +318,7 @@ function Complex64Array() {
 *
 * @name BYTES_PER_ELEMENT
 * @memberof Complex64Array
+* @readonly
 * @type {PositiveInteger}
 * @default 8
 *
@@ -293,18 +326,14 @@ function Complex64Array() {
 * var nbytes = Complex64Array.BYTES_PER_ELEMENT;
 * // returns 8
 */
-defineProperty( Complex64Array, 'BYTES_PER_ELEMENT', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': BYTES_PER_ELEMENT
-});
+setReadOnly( Complex64Array, 'BYTES_PER_ELEMENT', BYTES_PER_ELEMENT );
 
 /**
 * Constructor name.
 *
 * @name name
 * @memberof Complex64Array
+* @readonly
 * @type {string}
 * @default 'Complex64Array'
 *
@@ -312,12 +341,7 @@ defineProperty( Complex64Array, 'BYTES_PER_ELEMENT', {
 * var str = Complex64Array.name;
 * // returns 'Complex64Array'
 */
-defineProperty( Complex64Array, 'name', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': 'Complex64Array'
-});
+setReadOnly( Complex64Array, 'name', 'Complex64Array' );
 
 /**
 * Creates a new 64-bit complex number array from an array-like object or an iterable.
@@ -325,7 +349,7 @@ defineProperty( Complex64Array, 'name', {
 * @name from
 * @memberof Complex64Array
 * @type {Function}
-* @param {(ArrayLikeObject|Iterable)} src - array-like object or iterable
+* @param {(Collection|Iterable)} src - array-like object or iterable
 * @param {Function} [clbk] - callback to invoke for each source element
 * @param {*} [thisArg] - context
 * @throws {TypeError} `this` context must be a constructor
@@ -355,11 +379,11 @@ defineProperty( Complex64Array, 'name', {
 *
 * @example
 * var Complex64 = require( '@stdlib/complex-float32' );
-* var real = require( '@stdlib/complex-real' );
-* var imag = require( '@stdlib/complex-imag' );
+* var realf = require( '@stdlib/complex-realf' );
+* var imagf = require( '@stdlib/complex-imagf' );
 *
 * function clbk( v ) {
-*     return new Complex64( real(v)*2.0, imag(v)*2.0 );
+*     return new Complex64( realf(v)*2.0, imagf(v)*2.0 );
 * }
 *
 * var arr = Complex64Array.from( [ new Complex64( 1.0, 1.0 ) ], clbk );
@@ -368,107 +392,130 @@ defineProperty( Complex64Array, 'name', {
 * var len = arr.length;
 * // returns 1
 */
-defineProperty( Complex64Array, 'from', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function from( src ) {
-		var thisArg;
-		var nargs;
-		var clbk;
-		var out;
-		var buf;
-		var tmp;
-		var len;
-		var flg;
-		var v;
-		var i;
-		var j;
-		if ( !isFunction( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` context must be a constructor.' );
+setReadOnly( Complex64Array, 'from', function from( src ) {
+	var thisArg;
+	var nargs;
+	var clbk;
+	var out;
+	var buf;
+	var tmp;
+	var get;
+	var len;
+	var flg;
+	var v;
+	var i;
+	var j;
+	if ( !isFunction( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` context must be a constructor.' );
+	}
+	if ( !isComplexArrayConstructor( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	nargs = arguments.length;
+	if ( nargs > 1 ) {
+		clbk = arguments[ 1 ];
+		if ( !isFunction( clbk ) ) {
+			throw new TypeError( format( 'invalid argument. Second argument must be a function. Value: `%s`.', clbk ) );
 		}
-		if ( !isComplexArrayConstructor( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+		if ( nargs > 2 ) {
+			thisArg = arguments[ 2 ];
 		}
-		nargs = arguments.length;
-		if ( nargs > 1 ) {
-			clbk = arguments[ 1 ];
-			if ( !isFunction( clbk ) ) {
-				throw new TypeError( 'invalid argument. Second argument must be a function. Value: `'+clbk+'`.' );
-			}
-			if ( nargs > 2 ) {
-				thisArg = arguments[ 2 ];
+	}
+	if ( isComplexArray( src ) ) {
+		len = src.length;
+		if ( clbk ) {
+			out = new this( len );
+			buf = out._buffer; // eslint-disable-line no-underscore-dangle
+			j = 0;
+			for ( i = 0; i < len; i++ ) {
+				v = clbk.call( thisArg, src.get( i ), i );
+				if ( isComplexLike( v ) ) {
+					buf[ j ] = realf( v );
+					buf[ j+1 ] = imagf( v );
+				} else if ( isArrayLikeObject( v ) && v.length >= 2 ) {
+					buf[ j ] = v[ 0 ];
+					buf[ j+1 ] = v[ 1 ];
+				} else {
+					throw new TypeError( format( 'invalid argument. Callback must return either a two-element array containing real and imaginary components or a complex number. Value: `%s`.', v ) );
+				}
+				j += 2; // stride
 			}
+			return out;
 		}
-		if ( isCollection( src ) ) {
-			if ( clbk ) {
-				// Note: array contents affect how we iterate over a provided data source. If only complex numbers, we can extract real and imaginary components. Otherwise, we assume a strided array where real and imaginary components are interleaved. In the former case, we expect a callback to return real and imaginary components (possibly as a complex number). In the latter case, we expect a callback to return *either* a real or imaginary component.
+		return new this( src );
+	}
+	if ( isCollection( src ) ) {
+		if ( clbk ) {
+			// Note: array contents affect how we iterate over a provided data source. If only complex number objects, we can extract real and imaginary components. Otherwise, for non-complex number arrays (e.g., `Float64Array`, etc), we assume a strided array where real and imaginary components are interleaved. In the former case, we expect a callback to return real and imaginary components (possibly as a complex number). In the latter case, we expect a callback to return *either* a real or imaginary component.
 
-				// Detect whether we've been provided an array of complex numbers...
-				len = src.length;
-				for ( i = 0; i < len; i++ ) {
-					if ( !isComplexLike( src[ i ] ) ) {
-						flg = true;
-						break;
-					}
-				}
-				// If an array does not contain only complex numbers, then we assume interleaved real and imaginary components...
-				if ( flg ) {
-					if ( !isEven( len ) ) {
-						throw new RangeError( 'invalid argument. First argument must have a length which is a multiple of two. Length: `'+len+'`.' );
-					}
-					out = new this( len/2 );
-					buf = out._buffer; // eslint-disable-line no-underscore-dangle
-					for ( i = 0; i < len; i++ ) {
-						buf[ i ] = clbk.call( thisArg, src[ i ], i );
-					}
-				}
-				// If an array contains only complex numbers, then we need to extract real and imaginary components...
-				else {
-					out = new this( len );
-					buf = out._buffer; // eslint-disable-line no-underscore-dangle
-					j = 0;
-					for ( i = 0; i < len; i++ ) {
-						v = clbk.call( thisArg, src[ i ], i );
-						if ( isComplexLike( v ) ) {
-							buf[ j ] = real( v );
-							buf[ j+1 ] = imag( v );
-						} else if ( isArrayLikeObject( v ) && v.length >= 2 ) {
-							buf[ j ] = v[ 0 ];
-							buf[ j+1 ] = v[ 1 ];
-						} else {
-							throw new TypeError( 'invalid argument. Callback must return either a two-element array containing real and imaginary components or a complex number. Value: `'+v+'`.' );
-						}
-						j += 2; // stride
-					}
-				}
+			len = src.length;
+			if ( src.get && src.set ) {
+				get = accessorGetter( 'default' );
 			} else {
-				out = new this( src );
-			}
-		} else if ( isObject( src ) && HAS_ITERATOR_SYMBOL && isFunction( src[ ITERATOR_SYMBOL ] ) ) { // eslint-disable-line max-len
-			buf = src[ ITERATOR_SYMBOL ]();
-			if ( !isFunction( buf.next ) ) {
-				throw new TypeError( 'invalid argument. First argument must be an array-like object or an iterable.' );
+				get = getter( 'default' );
 			}
-			if ( clbk ) {
-				tmp = fromIteratorMap( buf, clbk, thisArg );
-			} else {
-				tmp = fromIterator( buf );
+			// Detect whether we've been provided an array which returns complex number objects...
+			for ( i = 0; i < len; i++ ) {
+				if ( !isComplexLike( get( src, i ) ) ) {
+					flg = true;
+					break;
+				}
 			}
-			if ( tmp instanceof Error ) {
-				throw tmp;
+			// If an array does not contain only complex number objects, then we assume interleaved real and imaginary components...
+			if ( flg ) {
+				if ( !isEven( len ) ) {
+					throw new RangeError( format( 'invalid argument. First argument must have a length which is a multiple of %u. Length: `%u`.', 2, len ) );
+				}
+				out = new this( len/2 );
+				buf = out._buffer; // eslint-disable-line no-underscore-dangle
+				for ( i = 0; i < len; i++ ) {
+					buf[ i ] = clbk.call( thisArg, get( src, i ), i );
+				}
+				return out;
 			}
-			len = tmp.length / 2;
+			// If an array contains only complex number objects, then we need to extract real and imaginary components...
 			out = new this( len );
 			buf = out._buffer; // eslint-disable-line no-underscore-dangle
+			j = 0;
 			for ( i = 0; i < len; i++ ) {
-				buf[ i ] = tmp[ i ];
+				v = clbk.call( thisArg, get( src, i ), i );
+				if ( isComplexLike( v ) ) {
+					buf[ j ] = realf( v );
+					buf[ j+1 ] = imagf( v );
+				} else if ( isArrayLikeObject( v ) && v.length >= 2 ) {
+					buf[ j ] = v[ 0 ];
+					buf[ j+1 ] = v[ 1 ];
+				} else {
+					throw new TypeError( format( 'invalid argument. Callback must return either a two-element array containing real and imaginary components or a complex number. Value: `%s`.', v ) );
+				}
+				j += 2; // stride
 			}
+			return out;
+		}
+		return new this( src );
+	}
+	if ( isObject( src ) && HAS_ITERATOR_SYMBOL && isFunction( src[ ITERATOR_SYMBOL ] ) ) { // eslint-disable-line max-len
+		buf = src[ ITERATOR_SYMBOL ]();
+		if ( !isFunction( buf.next ) ) {
+			throw new TypeError( format( 'invalid argument. First argument must be an array-like object or an iterable. Value: `%s`.', src ) );
+		}
+		if ( clbk ) {
+			tmp = fromIteratorMap( buf, clbk, thisArg );
 		} else {
-			throw new TypeError( 'invalid argument. First argument must be an array-like object or an iterable. Value: `'+src+'`.' );
+			tmp = fromIterator( buf );
+		}
+		if ( tmp instanceof Error ) {
+			throw tmp;
+		}
+		len = tmp.length / 2;
+		out = new this( len );
+		buf = out._buffer; // eslint-disable-line no-underscore-dangle
+		for ( i = 0; i < len; i++ ) {
+			buf[ i ] = tmp[ i ];
 		}
 		return out;
 	}
+	throw new TypeError( format( 'invalid argument. First argument must be an array-like object or an iterable. Value: `%s`.', src ) );
 });
 
 /**
@@ -489,25 +536,20 @@ defineProperty( Complex64Array, 'from', {
 * var len = arr.length;
 * // returns 2
 */
-defineProperty( Complex64Array, 'of', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function of() {
-		var args;
-		var i;
-		if ( !isFunction( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` context must be a constructor.' );
-		}
-		if ( !isComplexArrayConstructor( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
-		}
-		args = [];
-		for ( i = 0; i < arguments.length; i++ ) {
-			args.push( arguments[ i ] );
-		}
-		return new this( args );
+setReadOnly( Complex64Array, 'of', function of() {
+	var args;
+	var i;
+	if ( !isFunction( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` context must be a constructor.' );
+	}
+	if ( !isComplexArrayConstructor( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	args = [];
+	for ( i = 0; i < arguments.length; i++ ) {
+		args.push( arguments[ i ] );
 	}
+	return new this( args );
 });
 
 /**
@@ -515,6 +557,7 @@ defineProperty( Complex64Array, 'of', {
 *
 * @name buffer
 * @memberof Complex64Array.prototype
+* @readonly
 * @type {ArrayBuffer}
 *
 * @example
@@ -523,12 +566,8 @@ defineProperty( Complex64Array, 'of', {
 * var buf = arr.buffer;
 * // returns <ArrayBuffer>
 */
-defineProperty( Complex64Array.prototype, 'buffer', {
-	'configurable': false,
-	'enumerable': false,
-	'get': function get() {
-		return this._buffer.buffer;
-	}
+setReadOnlyAccessor( Complex64Array.prototype, 'buffer', function get() {
+	return this._buffer.buffer;
 });
 
 /**
@@ -536,6 +575,7 @@ defineProperty( Complex64Array.prototype, 'buffer', {
 *
 * @name byteLength
 * @memberof Complex64Array.prototype
+* @readonly
 * @type {NonNegativeInteger}
 *
 * @example
@@ -544,12 +584,8 @@ defineProperty( Complex64Array.prototype, 'buffer', {
 * var byteLength = arr.byteLength;
 * // returns 80
 */
-defineProperty( Complex64Array.prototype, 'byteLength', {
-	'configurable': false,
-	'enumerable': false,
-	'get': function get() {
-		return this._buffer.byteLength;
-	}
+setReadOnlyAccessor( Complex64Array.prototype, 'byteLength', function get() {
+	return this._buffer.byteLength;
 });
 
 /**
@@ -557,6 +593,7 @@ defineProperty( Complex64Array.prototype, 'byteLength', {
 *
 * @name byteOffset
 * @memberof Complex64Array.prototype
+* @readonly
 * @type {NonNegativeInteger}
 *
 * @example
@@ -565,12 +602,8 @@ defineProperty( Complex64Array.prototype, 'byteLength', {
 * var byteOffset = arr.byteOffset;
 * // returns 0
 */
-defineProperty( Complex64Array.prototype, 'byteOffset', {
-	'configurable': false,
-	'enumerable': false,
-	'get': function get() {
-		return this._buffer.byteOffset;
-	}
+setReadOnlyAccessor( Complex64Array.prototype, 'byteOffset', function get() {
+	return this._buffer.byteOffset;
 });
 
 /**
@@ -578,6 +611,7 @@ defineProperty( Complex64Array.prototype, 'byteOffset', {
 *
 * @name BYTES_PER_ELEMENT
 * @memberof Complex64Array.prototype
+* @readonly
 * @type {PositiveInteger}
 * @default 8
 *
@@ -587,12 +621,7 @@ defineProperty( Complex64Array.prototype, 'byteOffset', {
 * var nbytes = arr.BYTES_PER_ELEMENT;
 * // returns 8
 */
-defineProperty( Complex64Array.prototype, 'BYTES_PER_ELEMENT', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': Complex64Array.BYTES_PER_ELEMENT
-});
+setReadOnly( Complex64Array.prototype, 'BYTES_PER_ELEMENT', Complex64Array.BYTES_PER_ELEMENT );
 
 /**
 * Copies a sequence of elements within the array to the position starting at `target`.
@@ -608,8 +637,8 @@ defineProperty( Complex64Array.prototype, 'BYTES_PER_ELEMENT', {
 *
 * @example
 * var Complex64 = require( '@stdlib/complex-float32' );
-* var real = require( '@stdlib/complex-real' );
-* var imag = require( '@stdlib/complex-imag' );
+* var realf = require( '@stdlib/complex-realf' );
+* var imagf = require( '@stdlib/complex-imagf' );
 *
 * var arr = new Complex64Array( 4 );
 *
@@ -625,28 +654,23 @@ defineProperty( Complex64Array.prototype, 'BYTES_PER_ELEMENT', {
 * // Get the last array element:
 * var z = arr.get( 3 );
 *
-* var re = real( z );
+* var re = realf( z );
 * // returns 2.0
 *
-* var im = imag( z );
+* var im = imagf( z );
 * // returns 2.0
 */
-defineProperty( Complex64Array.prototype, 'copyWithin', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function copyWithin( target, start ) {
-		if ( !isComplexArray( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
-		}
-		// FIXME: prefer a functional `copyWithin` implementation which addresses lack of universal browser support (e.g., IE11 and Safari) or ensure that typed arrays are polyfilled
-		if ( arguments.length === 2 ) {
-			this._buffer.copyWithin( target*2, start*2 );
-		} else {
-			this._buffer.copyWithin( target*2, start*2, arguments[2]*2 );
-		}
-		return this;
+setReadOnly( Complex64Array.prototype, 'copyWithin', function copyWithin( target, start ) {
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
 	}
+	// FIXME: prefer a functional `copyWithin` implementation which addresses lack of universal browser support (e.g., IE11 and Safari) or ensure that typed arrays are polyfilled
+	if ( arguments.length === 2 ) {
+		this._buffer.copyWithin( target*2, start*2 );
+	} else {
+		this._buffer.copyWithin( target*2, start*2, arguments[2]*2 );
+	}
+	return this;
 });
 
 /**
@@ -684,104 +708,85 @@ defineProperty( Complex64Array.prototype, 'copyWithin', {
 * var bool = it.next().done;
 * // returns true
 */
-defineProperty( Complex64Array.prototype, 'entries', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function entries() {
-		var buffer;
-		var self;
-		var iter;
-		var len;
-		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;
-		len = this._length;
+setReadOnly( Complex64Array.prototype, 'entries', function entries() {
+	var buffer;
+	var self;
+	var iter;
+	var len;
+	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;
+	len = this._length;
 
-		// Initialize the iteration indices:
-		i = -1;
-		j = -2;
+	// Initialize the iteration indices:
+	i = -1;
+	j = -2;
 
-		// Create an iterator protocol-compliant object:
-		iter = {};
-		defineProperty( iter, 'next', {
-			'configurable': false,
-			'enumerable': false,
-			'writable': false,
-			'value': next
-		});
-		defineProperty( iter, 'return', {
-			'configurable': false,
-			'enumerable': false,
-			'writable': false,
-			'value': end
-		});
-		if ( ITERATOR_SYMBOL ) {
-			defineProperty( iter, ITERATOR_SYMBOL, {
-				'configurable': false,
-				'enumerable': false,
-				'writable': false,
-				'value': factory
-			});
-		}
-		return iter;
+	// Create an iterator protocol-compliant object:
+	iter = {};
+	setReadOnly( iter, 'next', next );
+	setReadOnly( iter, 'return', end );
 
-		/**
-		* Returns an iterator protocol-compliant object containing the next iterated value.
-		*
-		* @private
-		* @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 ] );
+	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() {
+		var z;
+		i += 1;
+		if ( FLG || i >= len ) {
 			return {
-				'value': [ i, z ],
-				'done': false
+				'done': true
 			};
 		}
+		j += 2;
+		z = new Complex64( buffer[ j ], buffer[ j+1 ] );
+		return {
+			'value': [ i, z ],
+			'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
-				};
-			}
+	/**
+	* 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.entries();
-		}
+	/**
+	* Returns a new iterator.
+	*
+	* @private
+	* @returns {Iterator} iterator
+	*/
+	function factory() {
+		return self.entries();
 	}
 });
 
@@ -791,63 +796,53 @@ defineProperty( Complex64Array.prototype, 'entries', {
 * @name get
 * @memberof Complex64Array.prototype
 * @type {Function}
-* @param {ArrayLikeObject} [out] - output array
-* @param {NonNegativeInteger} i - element index
+* @param {NonNegativeInteger} idx - element index
 * @throws {TypeError} `this` must be a complex number array
-* @throws {TypeError} index argument must be a nonnegative integer
-* @throws {TypeError} output argument must be an array-like object
-* @returns {(Complex64|ArrayLikeObject|void)} array element
+* @throws {TypeError} must provide a nonnegative integer
+* @returns {(Complex64|void)} array element
 *
 * @example
 * var arr = new Complex64Array( 10 );
+* var realf = require( '@stdlib/complex-realf' );
+* var imagf = require( '@stdlib/complex-imagf' );
 *
 * 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.0, 0.0 ], 0 );
-* // returns [ 1.0, -1.0 ]
+* z = arr.get( 0 );
+* // returns <Complex64>
+*
+* re = realf( z );
+* // returns 1.0
+*
+* im = imagf( z );
+* // returns -1.0
 *
 * z = arr.get( 100 );
 * // returns undefined
 */
-defineProperty( Complex64Array.prototype, 'get', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function get( i ) {
-		var idx;
-		var out;
-		var buf;
-
-		if ( !isComplexArray( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
-		}
-		buf = this._buffer;
-		if ( arguments.length > 1 ) {
-			idx = arguments[ 1 ];
-			out = i;
-			if ( !isArrayLikeObject( out ) || out.length < 2 ) {
-				throw new TypeError( 'invalid argument. Output argument must be an array-like object. Value: `'+out+'`.' );
-			}
-		} else {
-			idx = i;
-		}
-		if ( !isNonNegativeInteger( idx ) ) {
-			throw new TypeError( 'invalid argument. Index argument must be a nonnegative integer. Value: `'+idx+'`.' );
-		}
-		if ( idx >= this._length ) {
-			return;
-		}
-		idx *= 2;
-		if ( out ) {
-			out[ 0 ] = buf[ idx ];
-			out[ 1 ] = buf[ idx+1 ];
-			return out;
-		}
-		return new Complex64( buf[ idx ], buf[ idx+1 ] );
+setReadOnly( Complex64Array.prototype, 'get', function get( idx ) {
+	var buf;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isNonNegativeInteger( idx ) ) {
+		throw new TypeError( format( 'invalid argument. Must provide a nonnegative integer. Value: `%s`.', idx ) );
+	}
+	if ( idx >= this._length ) {
+		return;
 	}
+	buf = this._buffer;
+	idx *= 2;
+	return new Complex64( buf[ idx ], buf[ idx+1 ] );
 });
 
 /**
@@ -855,6 +850,7 @@ defineProperty( Complex64Array.prototype, 'get', {
 *
 * @name length
 * @memberof Complex64Array.prototype
+* @readonly
 * @type {NonNegativeInteger}
 *
 * @example
@@ -863,12 +859,8 @@ defineProperty( Complex64Array.prototype, 'get', {
 * var len = arr.length;
 * // returns 10
 */
-defineProperty( Complex64Array.prototype, 'length', {
-	'configurable': false,
-	'enumerable': false,
-	'get': function get() {
-		return this._length;
-	}
+setReadOnlyAccessor( Complex64Array.prototype, 'length', function get() {
+	return this._length;
 });
 
 /**
@@ -909,18 +901,18 @@ defineProperty( Complex64Array.prototype, 'length', {
 * @returns {void}
 *
 * @example
-* var real = require( '@stdlib/complex-real' );
-* var imag = require( '@stdlib/complex-imag' );
+* 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 = real( z );
+* var re = realf( z );
 * // returns 0.0
 *
-* var im = imag( z );
+* var im = imagf( z );
 * // returns 0.0
 *
 * arr.set( [ 1.0, -1.0 ], 0 );
@@ -928,54 +920,95 @@ defineProperty( Complex64Array.prototype, 'length', {
 * z = arr.get( 0 );
 * // returns <Complex64>
 *
-* re = real( z );
+* re = realf( z );
 * // returns 1.0
 *
-* im = imag( z );
+* im = imagf( z );
 * // returns -1.0
 */
-defineProperty( Complex64Array.prototype, 'set', {
-	'configurable': false,
-	'enumerable': false,
-	'writable': false,
-	'value': function set( value ) {
-		/* eslint-disable no-underscore-dangle */
-		var sbuf;
-		var idx;
-		var buf;
-		var tmp;
-		var flg;
-		var N;
-		var v;
-		var i;
-		var j;
-		if ( !isComplexArray( this ) ) {
-			throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+setReadOnly( Complex64Array.prototype, 'set', function set( value ) {
+	/* eslint-disable no-underscore-dangle */
+	var sbuf;
+	var idx;
+	var buf;
+	var tmp;
+	var flg;
+	var N;
+	var v;
+	var i;
+	var j;
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	buf = this._buffer;
+	if ( arguments.length > 1 ) {
+		idx = arguments[ 1 ];
+		if ( !isNonNegativeInteger( idx ) ) {
+			throw new TypeError( format( 'invalid argument. Index argument must be a nonnegative integer. Value: `%s`.', idx ) );
 		}
-		buf = this._buffer;
-		if ( arguments.length > 1 ) {
-			idx = arguments[ 1 ];
-			if ( !isNonNegativeInteger( idx ) ) {
-				throw new TypeError( 'invalid argument. Index argument must be a nonnegative integer. Value: `'+idx+'`.' );
+	} else {
+		idx = 0;
+	}
+	if ( isComplexLike( value ) ) {
+		if ( idx >= this._length ) {
+			throw new RangeError( format( 'invalid argument. Index argument is out-of-bounds. Value: `%u`.', idx ) );
+		}
+		idx *= 2;
+		buf[ idx ] = realf( value );
+		buf[ idx+1 ] = imagf( value );
+		return;
+	}
+	if ( isComplexArray( value ) ) {
+		N = value._length;
+		if ( idx+N > this._length ) {
+			throw new RangeError( 'invalid arguments. Target array lacks sufficient storage to accommodate source values.' );
+		}
+		sbuf = value._buffer;
+
+		// Check for overlapping memory...
+		j = buf.byteOffset + (idx*BYTES_PER_ELEMENT);
+		if (
+			sbuf.buffer === buf.buffer &&
+			(
+				sbuf.byteOffset < j &&
+				sbuf.byteOffset+sbuf.byteLength > j
+			)
+		) {
+			// We need to copy source values...
+			tmp = new Float32Array( sbuf.length );
+			for ( i = 0; i < sbuf.length; i++ ) {
+				tmp[ i ] = sbuf[ i ];
 			}
-		} else {
-			idx = 0;
+			sbuf = tmp;
+		}
+		idx *= 2;
+		j = 0;
+		for ( i = 0; i < N; i++ ) {
+			buf[ idx ] = sbuf[ j ];
+			buf[ idx+1 ] = sbuf[ j+1 ];
+			idx += 2; // stride
+			j += 2; // stride
 		}
-		if ( isComplexLike( value ) ) {
-			if ( idx >= this._length ) {
-				throw new RangeError( 'invalid argument. Index argument is out-of-bounds. Value: `'+idx+'`.' );
+		return;
+	}
+	if ( isCollection( value ) ) {
+		// Detect whether we've been provided an array of complex numbers...
+		N = value.length;
+		for ( i = 0; i < N; i++ ) {
+			if ( !isComplexLike( value[ i ] ) ) {
+				flg = true;
+				break;
 			}
-			idx *= 2;
-			buf[ idx ] = real( value );
-			buf[ idx+1 ] = imag( value );
-			return;
 		}
-		if ( isComplexArray( value ) ) {
-			N = value._length;
-			if ( idx+N > this._length ) {
+		// If an array does not contain only complex numbers, then we assume interleaved real and imaginary components...
+		if ( flg ) {
+			if ( !isEven( N ) ) {
+				throw new RangeError( format( 'invalid argument. Array-like object arguments must have a length which is a multiple of two. Length: `%u`.', N ) );
+			}
+			if ( idx+(N/2) > this._length ) {
 				throw new RangeError( 'invalid arguments. Target array lacks sufficient storage to accommodate source values.' );
 			}
-			sbuf = value._buffer;
+			sbuf = value;
 
 			// Check for overlapping memory...
 			j = buf.byteOffset + (idx*BYTES_PER_ELEMENT);
@@ -987,13 +1020,14 @@ defineProperty( Complex64Array.prototype, 'set', {
 				)
 			) {
 				// We need to copy source values...
-				tmp = new Float32Array( sbuf.length );
-				for ( i = 0; i < sbuf.length; i++ ) {
+				tmp = new Float32Array( N );
+				for ( i = 0; i < N; i++ ) {
 					tmp[ i ] = sbuf[ i ];
 				}
 				sbuf = tmp;
 			}
 			idx *= 2;
+			N /= 2;
 			j = 0;
 			for ( i = 0; i < N; i++ ) {
 				buf[ idx ] = sbuf[ j ];
@@ -1003,69 +1037,22 @@ defineProperty( Complex64Array.prototype, 'set', {
 			}
 			return;
 		}
-		if ( isCollection( value ) ) {
-			// Detect whether we've been provided an array of complex numbers...
-			N = value.length;
-			for ( i = 0; i < N; i++ ) {
-				if ( !isComplexLike( value[ i ] ) ) {
-					flg = true;
-					break;
-				}
-			}
-			// If an array does not contain only complex numbers, then we assume interleaved real and imaginary components...
-			if ( flg ) {
-				if ( !isEven( N ) ) {
-					throw new RangeError( 'invalid argument. Array-like object arguments must have a length which is a multiple of two. Length: `'+N+'`.' );
-				}
-				if ( idx+(N/2) > this._length ) {
-					throw new RangeError( 'invalid arguments. Target array lacks sufficient storage to accommodate source values.' );
-				}
-				sbuf = value;
-
-				// Check for overlapping memory...
-				j = buf.byteOffset + (idx*BYTES_PER_ELEMENT);
-				if (
-					sbuf.buffer === buf.buffer &&
-					(
-						sbuf.byteOffset < j &&
-						sbuf.byteOffset+sbuf.byteLength > j
-					)
-				) {
-					// We need to copy source values...
-					tmp = new Float32Array( N );
-					for ( i = 0; i < N; i++ ) {
-						tmp[ i ] = sbuf[ i ];
-					}
-					sbuf = tmp;
-				}
-				idx *= 2;
-				N /= 2;
-				j = 0;
-				for ( i = 0; i < N; i++ ) {
-					buf[ idx ] = sbuf[ j ];
-					buf[ idx+1 ] = sbuf[ j+1 ];
-					idx += 2; // stride
-					j += 2; // stride
-				}
-				return;
-			}
-			// If an array contains only complex numbers, then we need to extract real and imaginary components...
-			if ( idx+N > this._length ) {
-				throw new RangeError( 'invalid arguments. Target array lacks sufficient storage to accommodate source values.' );
-			}
-			idx *= 2;
-			for ( i = 0; i < N; i++ ) {
-				v = value[ i ];
-				buf[ idx ] = real( v );
-				buf[ idx+1 ] = imag( v );
-				idx += 2; // stride
-			}
-			return;
+		// If an array contains only complex numbers, then we need to extract real and imaginary components...
+		if ( idx+N > this._length ) {
+			throw new RangeError( 'invalid arguments. Target array lacks sufficient storage to accommodate source values.' );
 		}
-		throw new TypeError( 'invalid argument. First argument must be either a complex number, an array-like object, or a complex number array. Value: `'+value+'`.' );
-
-		/* eslint-enable no-underscore-dangle */
+		idx *= 2;
+		for ( i = 0; i < N; i++ ) {
+			v = value[ i ];
+			buf[ idx ] = realf( v );
+			buf[ idx+1 ] = imagf( v );
+			idx += 2; // stride
+		}
+		return;
 	}
+	throw new TypeError( format( 'invalid argument. First argument must be either a complex number, an array-like object, or a complex number array. Value: `%s`.', value ) );
+
+	/* eslint-enable no-underscore-dangle */
 });