@stdlib/array-complex64 0.1.0 → 0.2.0

package/README.md

@@ -537,6 +537,56 @@ len = arr.length;
 // returns 2
 ```
 
+<a name="method-at"></a>
+
+#### Complex64Array.prototype.at( i )
+
+Returns an array element located at integer position (index) `i`, with support for both nonnegative and negative integer positions.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Set the first, second, and last elements:
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, -2.0 ], 1 );
+arr.set( [ 9.0, -9.0 ], 9 );
+
+// Get the first element:
+var z = arr.at( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 1.0
+
+var im = imagf( z );
+// returns -1.0
+
+// Get the last element:
+z = arr.at( -1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 9.0
+
+im = imagf( z );
+// returns -9.0
+```
+
+If provided an out-of-bounds index, the method returns `undefined`.
+
+```javascript
+var arr = new Complex64Array( 10 );
+
+var z = arr.at( 100 );
+// returns undefined
+
+z = arr.at( -100 );
+// returns undefined
+```
+
 <a name="method-copy-within"></a>
 
 #### Complex64Array.prototype.copyWithin( target, start\[, end] )
@@ -771,172 +821,1351 @@ var bool = it.next().done;
 // returns true
 ```
 
-<a name="method-get"></a>
+<a name="method-every"></a>
 
-#### Complex64Array.prototype.get( i )
+#### Complex64Array.prototype.every( predicate\[, thisArg] )
 
-Returns an array element located at position (index) `i`.
+Returns a boolean indicating whether all elements pass a test.
 
 ```javascript
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
-var arr = new Complex64Array( 10 );
-
-// Set the first element:
-arr.set( [ 1.0, -1.0 ], 0 );
+function predicate( v ) {
+    return ( realf( v ) === imagf( v ) );
+}
 
-// Get the first element:
-var z = arr.get( 0 );
-// returns <Complex64>
+var arr = new Complex64Array( 3 );
 
-var re = realf( z );
-// returns 1.0
+// Set the first three elements:
+arr.set( [ 1.0, 1.0 ], 0 );
+arr.set( [ 2.0, 2.0 ], 1 );
+arr.set( [ 3.0, 3.0 ], 2 );
 
-var im = imagf( z );
-// returns -1.0
+// Check whether all elements pass a test:
+var z = arr.every( predicate );
+// returns true
 ```
 
-If provided an out-of-bounds index, the method returns `undefined`.
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
 
 ```javascript
-var arr = new Complex64Array( 10 );
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 );
+}
 
-var z = arr.get( 100 );
-// returns undefined
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+arr.set( [ 1.0, 1.0 ], 0 );
+arr.set( [ 2.0, 2.0 ], 1 );
+arr.set( [ 3.0, 3.0 ], 2 );
+
+var z = arr.every( predicate, context );
+// returns true
+
+var count = context.count;
+// returns 3
 ```
 
-<a name="method-set"></a>
+<a name="method-fill"></a>
 
-#### Complex64Array.prototype.set( z\[, i] )
+#### Complex64Array.prototype.fill( value\[, start\[, end]] )
 
-Sets one or more array elements.
+Returns a modified typed array filled with a fill value.
 
 ```javascript
 var Complex64 = require( '@stdlib/complex-float32' );
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
-var arr = new Complex64Array( 10 );
+var arr = new Complex64Array( 3 );
+
+// Set all elements to the same value:
+arr.fill( new Complex64( 1.0, 1.0 ) );
 
-// Get the first element:
 var z = arr.get( 0 );
 // returns <Complex64>
 
 var re = realf( z );
-// returns 0.0
+// returns 1.0
 
 var im = imagf( z );
-// returns 0.0
+// returns 1.0
 
-// Set the first element:
-arr.set( new Complex64( 1.0, -1.0 ) );
+z = arr.get( 2 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 1.0
+
+im = imagf( z );
+// returns 1.0
+
+// Fill all elements starting from the second element:
+arr.fill( new Complex64( 2.0, 2.0 ), 1 );
+
+z = arr.get( 1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 2.0
+
+im = imagf( z );
+// returns 2.0
+
+z = arr.get( 2 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 2.0
+
+im = imagf( z );
+// returns 2.0
+
+// Fill all elements from first element until the second-to-last element:
+arr.fill( new Complex64( 3.0, 3.0 ), 0, 2 );
 
-// Get the first element:
 z = arr.get( 0 );
 // returns <Complex64>
 
 re = realf( z );
-// returns 1.0
+// returns 3.0
 
 im = imagf( z );
-// returns -1.0
+// returns 3.0
+
+z = arr.get( 1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 3.0
+
+im = imagf( z );
+// returns 3.0
 ```
 
-By default, the method sets array elements starting at position (index) `i = 0`. To set elements starting elsewhere in the array, provide an index argument `i`.
+When a `start` and/or `end` index is negative, the respective index is determined relative to the last array element.
 
 ```javascript
 var Complex64 = require( '@stdlib/complex-float32' );
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
-var arr = new Complex64Array( 10 );
+var arr = new Complex64Array( 3 );
 
-// Get the fifth element:
-var z = arr.get( 4 );
+// Set all array elements, except the last element, to the same value:
+arr.fill( new Complex64( 1.0, 1.0 ), 0, -1 );
+
+var z = arr.get( 0 );
 // returns <Complex64>
 
 var re = realf( z );
-// returns 0.0
+// returns 1.0
 
 var im = imagf( z );
-// returns 0.0
-
-// Set the fifth element:
-arr.set( new Complex64( 1.0, -1.0 ), 4 );
+// returns 1.0
 
-// Get the fifth element:
-z = arr.get( 4 );
+z = arr.get( arr.length - 1 );
 // returns <Complex64>
 
 re = realf( z );
-// returns 1.0
+// returns 0.0
 
 im = imagf( z );
-// returns -1.0
+// returns 0.0
 ```
 
-In addition to providing a complex number, to set one or more array elements, provide an array-like object containing either complex numbers
+<a name="method-filter"></a>
+
+#### Complex64Array.prototype.filter( predicate\[, thisArg] )
+
+Returns a new array containing the elements of an array which pass a test implemented by a predicate function.
 
 ```javascript
-var Complex64 = require( '@stdlib/complex-float32' );
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
-var arr = new Complex64Array( 10 );
+function predicate( v ) {
+    return ( realf( v ) === imagf( v ) );
+}
 
-// Define an array of complex numbers:
-var buf = [
-    new Complex64( 1.0, -1.0 ),
-    new Complex64( 2.0, -2.0 ),
-    new Complex64( 3.0, -3.0 )
-];
+var arr = new Complex64Array( 3 );
 
-// Set the fifth, sixth, and seventh elements:
-arr.set( buf, 4 );
+// Set the first three elements:
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, 2.0 ], 1 );
+arr.set( [ 3.0, -3.0 ], 2 );
 
-// Get the sixth element:
-var z = arr.get( 5 );
+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
+// returns 2.0
 ```
 
-or interleaved real and imaginary components
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
 
 ```javascript
-var Float32Array = require( '@stdlib/array-float32' );
 var realf = require( '@stdlib/complex-realf' );
 var imagf = require( '@stdlib/complex-imagf' );
 
-var arr = new Complex64Array( 10 );
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
 
-// Define an interleaved array of real and imaginary components:
-var buf = new Float32Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, -3.0 ] );
+var arr = new Complex64Array( 3 );
 
-// Set the fifth, sixth, and seventh elements:
-arr.set( buf, 4 );
+var context = {
+    'count': 0
+};
 
-// Get the sixth element:
-var z = arr.get( 5 );
+// Set the first three elements:
+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, context );
+// returns <Complex64Array>
+
+var len = out.length;
+// returns 2
+
+var count = context.count;
+// returns 3
+```
+
+<a name="method-find"></a>
+
+#### Complex64Array.prototype.find( predicate\[, thisArg] )
+
+Returns the first element in an array for which a predicate function returns a truthy value.
+
+```javascript
+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 );
+
+// Set the first three elements:
+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
+```
+
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+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, context );
 // returns <Complex64>
 
 var re = realf( z );
 // returns 2.0
 
 var im = imagf( z );
-// returns -2.0
+// returns 2.0
+
+var count = context.count;
+// returns 2
 ```
 
-A few notes:
+<a name="method-find-index"></a>
 
--   If `i` is out-of-bounds, the method throws an error.
--   If a target array cannot accommodate all values (i.e., the length of source array plus `i` exceeds the target array length), the method throws an error.
--   If provided a [typed array][@stdlib/array/typed] which shares an [`ArrayBuffer`][@stdlib/array/buffer] with the target array, the method will intelligently copy the source range to the destination range.
+#### Complex64Array.prototype.findIndex( predicate\[, thisArg] )
+
+Returns the index of the first element in an array for which a predicate function returns a truthy value.
+
+```javascript
+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 );
+
+// Set the first three elements:
+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
+```
+
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+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, context );
+// returns -1
+
+var count = context.count;
+// returns 3
+```
+
+<a name="method-find-last"></a>
+
+#### Complex64Array.prototype.findLast( predicate\[, thisArg] )
+
+Returns the last element in an array for which a predicate function returns a truthy value.
+
+```javascript
+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 );
+
+// Set the first three elements:
+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
+```
+
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+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, context );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 2.0
+
+var im = imagf( z );
+// returns 2.0
+
+var count = context.count;
+// returns 2
+```
+
+<a name="method-find-last-index"></a>
+
+#### Complex64Array.prototype.findLastIndex( predicate\[, thisArg] )
+
+Returns the index of the last element in an array for which a predicate function returns a truthy value.
+
+```javascript
+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 );
+
+// Set the first three elements:
+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
+```
+
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+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, context );
+// returns -1
+
+var count = context.count;
+// returns 3
+```
+
+<a name="method-for-each"></a>
+
+#### Complex64Array.prototype.forEach( callbackFn\[, thisArg] )
+
+Invokes a function once for each array element.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+
+function log( v, i ) {
+    console.log( '%s: %s', i, v.toString() );
+}
+
+var arr = new Complex64Array( 3 );
+
+// Set the first three elements:
+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
+*/
+```
+
+The invoked function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+
+function fcn( v, i ) {
+    this.count += 1;
+    console.log( '%s: %s', i, v.toString() );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, -2.0 ], 1 );
+arr.set( [ 3.0, -3.0 ], 2 );
+
+arr.forEach( fcn, context );
+/* =>
+    0: 1 + 1i
+    1: 2 + 2i
+    2: 3 + 3i
+*/
+
+var count = context.count;
+// returns 3
+```
+
+<a name="method-get"></a>
+
+#### Complex64Array.prototype.get( i )
+
+Returns an array element located at a nonnegative integer position (index) `i`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Set the first element:
+arr.set( [ 1.0, -1.0 ], 0 );
+
+// Get the first element:
+var z = arr.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 1.0
+
+var im = imagf( z );
+// returns -1.0
+```
+
+If provided an out-of-bounds index, the method returns `undefined`.
+
+```javascript
+var arr = new Complex64Array( 10 );
+
+var z = arr.get( 100 );
+// returns undefined
+```
+
+<a name="method-includes"></a>
+
+#### Complex64Array.prototype.includes( searchElement\[, fromIndex] )
+
+Returns a boolean indicating whether an array includes a provided value.
+
+```javascript
+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( [ 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
+```
+
+<a name="method-index-of"></a>
+
+#### Complex64Array.prototype.indexOf( searchElement\[, fromIndex] )
+
+Returns the first index at which a given element can be found.
+
+```javascript
+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( [ 2.0, -2.0 ], 4 );
+
+var idx = arr.indexOf( new Complex64( 3.0, -3.0 ) );
+// returns 2
+
+idx = arr.indexOf( new Complex64( 2.0, -2.0 ), 2 );
+// returns 4
+
+idx = arr.indexOf( new Complex64( 4.0, -4.0 ), -3 );
+// returns 3
+```
+
+If `searchElement` is not present in the array, the method returns `-1`.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+
+var arr = new Complex64Array( 10 );
+
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, -2.0 ], 1 );
+
+var idx = arr.indexOf( new Complex64( 3.0, -3.0 ) );
+// returns -1
+
+idx = arr.indexOf( new Complex64( 1.0, -1.0 ), 1 );
+// returns -1
+```
+
+<a name="method-join"></a>
+
+#### Complex64Array.prototype.join( \[separator] )
+
+Returns a new string by concatenating all array elements.
+
+```javascript
+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 str = arr.join();
+// returns '1 + 1i,2 - 2i,3 + 3i'
+```
+
+By default, the method separates serialized array elements with a comma. To use an alternative separator, provide a `separator` string.
+
+```javascript
+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 str = arr.join( '/' );
+// returns '1 + 1i/2 - 2i/3 + 3i'
+```
+
+<a name="method-last-index-of"></a>
+
+#### Complex64Array.prototype.lastIndexOf( searchElement\[, fromIndex] )
+
+Returns the last index at which a given element can be found.
+
+```javascript
+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( [ 2.0, -2.0 ], 4 );
+
+var idx = arr.lastIndexOf( new Complex64( 3.0, -3.0 ) );
+// returns 2
+
+idx = arr.lastIndexOf( new Complex64( 2.0, -2.0 ), 2 );
+// returns 1
+
+idx = arr.lastIndexOf( new Complex64( 4.0, -4.0 ), -1 );
+// returns 3
+```
+
+If `searchElement` is not present in the array, the method returns `-1`.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+
+var arr = new Complex64Array( 10 );
+
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, -2.0 ], 1 );
+
+var idx = arr.lastIndexOf( new Complex64( 3.0, -3.0 ) );
+// returns -1
+
+idx = arr.lastIndexOf( new Complex64( 2.0, -2.0 ), 0 );
+// returns -1
+```
+
+<a name="method-map"></a>
+
+#### Complex64Array.prototype.map( callbackFn\[, thisArg] )
+
+Returns a new array with each element being the result of a provided callback function.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function scale( v ) {
+    return new Complex64( 2.0*realf( v ), 2.0*imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+// Set the first three elements:
+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
+```
+
+The callback function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function scale( v ) {
+    this.count += 1;
+    return new Complex64( 2.0*realf( v ), 2.0*imagf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+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, context );
+// returns <Complex64Array>
+
+var count = context.count;
+// returns 3
+```
+
+<a name="method-reverse"></a>
+
+#### Complex64Array.prototype.reverse()
+
+Reverses an array in-place.
+
+```javascript
+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
+```
+
+<a name="method-set"></a>
+
+#### Complex64Array.prototype.set( z\[, i] )
+
+Sets one or more array elements.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Get the first element:
+var z = arr.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 0.0
+
+var im = imagf( z );
+// returns 0.0
+
+// Set the first element:
+arr.set( new Complex64( 1.0, -1.0 ) );
+
+// Get the first element:
+z = arr.get( 0 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 1.0
+
+im = imagf( z );
+// returns -1.0
+```
+
+By default, the method sets array elements starting at position (index) `i = 0`. To set elements starting elsewhere in the array, provide an index argument `i`.
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Get the fifth element:
+var z = arr.get( 4 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 0.0
+
+var im = imagf( z );
+// returns 0.0
+
+// Set the fifth element:
+arr.set( new Complex64( 1.0, -1.0 ), 4 );
+
+// Get the fifth element:
+z = arr.get( 4 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 1.0
+
+im = imagf( z );
+// returns -1.0
+```
+
+In addition to providing a complex number, to set one or more array elements, provide an array-like object containing either complex numbers
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Define an array of complex numbers:
+var buf = [
+    new Complex64( 1.0, -1.0 ),
+    new Complex64( 2.0, -2.0 ),
+    new Complex64( 3.0, -3.0 )
+];
+
+// Set the fifth, sixth, and seventh elements:
+arr.set( buf, 4 );
+
+// Get the sixth element:
+var z = arr.get( 5 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 2.0
+
+var im = imagf( z );
+// returns -2.0
+```
+
+or interleaved real and imaginary components
+
+```javascript
+var Float32Array = require( '@stdlib/array-float32' );
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( 10 );
+
+// Define an interleaved array of real and imaginary components:
+var buf = new Float32Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, -3.0 ] );
+
+// Set the fifth, sixth, and seventh elements:
+arr.set( buf, 4 );
+
+// Get the sixth element:
+var z = arr.get( 5 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 2.0
+
+var im = imagf( z );
+// returns -2.0
+```
+
+A few notes:
+
+-   If `i` is out-of-bounds, the method throws an error.
+-   If a target array cannot accommodate all values (i.e., the length of source array plus `i` exceeds the target array length), the method throws an error.
+-   If provided a [typed array][@stdlib/array/typed] which shares an [`ArrayBuffer`][@stdlib/array/buffer] with the target array, the method will intelligently copy the source range to the destination range.
+
+<a name="method-slice"></a>
+
+#### Complex64Array.prototype.slice( \[start\[, end]] )
+
+Copies a portion of a typed array to a new typed array.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var out = arr.slice();
+// returns <Complex64Array>
+
+var len = out.length;
+// returns 4
+
+var z = out.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 1.0
+
+var im = imagf( z );
+// returns 2.0
+
+z = out.get( len-1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 7.0
+
+im = imagf( z );
+// returns 8.0
+```
+
+By default, the method returns a typed array beginning with the first array element. To specify an alternative array index at which to begin, provide a `start` index (inclusive).
+
+```javascript
+var imagf = require( '@stdlib/complex-imagf' );
+var realf = require( '@stdlib/complex-realf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var out = arr.slice( 1 );
+// returns <Complex64Array>
+
+var len = out.length;
+// returns 3
+
+var z = out.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 3.0
+
+var im = imagf( z );
+// returns 4.0
+```
+
+By default, the method returns a typed array which includes all array elements after `start`. To limit the number of array elements after `start`, provide an `end` index (exclusive).
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var out = arr.slice( 1, -1 );
+// returns <Complex64Array>
+
+var len = out.length;
+// returns 2
+
+var z = out.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 3.0
+
+var im = imagf( z );
+// returns 4.0
+
+z = out.get( len-1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 5.0
+
+im = imagf( z );
+// returns 6.0
+```
+
+<a name="method-some"></a>
+
+#### Complex64Array.prototype.some( predicate\[, thisArg] )
+
+Returns a boolean indicating whether at least one element passes a test.
+
+```javascript
+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 );
+
+// Set the first three elements:
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, 2.0 ], 1 );
+arr.set( [ 3.0, -3.0 ], 2 );
+
+// Check whether at least one element passes a test:
+var z = arr.some( predicate );
+// returns true
+```
+
+The `predicate` function is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
+
+To set the function execution context, provide a `thisArg`.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+function predicate( v, i ) {
+    this.count += 1;
+    return ( imagf( v ) === realf( v ) );
+}
+
+var arr = new Complex64Array( 3 );
+
+var context = {
+    'count': 0
+};
+
+// Set the first three elements:
+arr.set( [ 1.0, -1.0 ], 0 );
+arr.set( [ 2.0, 2.0 ], 1 );
+arr.set( [ 3.0, -3.0 ], 2 );
+
+var z = arr.some( predicate, context );
+// returns true
+
+var count = context.count;
+// returns 2
+```
+
+<a name="method-subarray"></a>
+
+#### Complex64Array.prototype.subarray( \[begin\[, end]] )
+
+Creates a new typed array view over the same underlying [`ArrayBuffer`][@stdlib/array/buffer] and with the same underlying data type as the host array.
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var subarr = arr.subarray();
+// returns <Complex64Array>
+
+var len = subarr.length;
+// returns 4
+
+var z = subarr.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 1.0
+
+var im = imagf( z );
+// returns 2.0
+
+z = subarr.get( len-1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 7.0
+
+im = imagf( z );
+// returns 8.0
+```
+
+By default, the method creates a typed array view beginning with the first array element. To specify an alternative array index at which to begin, provide a `begin` index (inclusive).
+
+```javascript
+var imagf = require( '@stdlib/complex-imagf' );
+var realf = require( '@stdlib/complex-realf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var subarr = arr.subarray( 1 );
+// returns <Complex64Array>
+
+var len = subarr.length;
+// returns 3
+
+var z = subarr.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 3.0
+
+var im = imagf( z );
+// returns 4.0
+```
+
+By default, the method creates a typed array view which includes all array elements after `begin`. To limit the number of array elements after `begin`, provide an `end` index (exclusive).
+
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
+
+var arr = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+
+var subarr = arr.subarray( 1, -1 );
+// returns <Complex64Array>
+
+var len = subarr.length;
+// returns 2
+
+var z = subarr.get( 0 );
+// returns <Complex64>
+
+var re = realf( z );
+// returns 3.0
+
+var im = imagf( z );
+// returns 4.0
+
+z = subarr.get( len-1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 5.0
+
+im = imagf( z );
+// returns 6.0
+```
+
+<a name="method-to-reversed"></a>
+
+#### Complex64Array.prototype.toReversed()
+
+Returns a new typed array containing the elements in reversed order.
+
+```javascript
+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
+```
+
+<a name="method-to-string"></a>
+
+#### Complex64Array.prototype.toString()
+
+Serializes an array as a string.
+
+```javascript
+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 str = arr.toString();
+// returns '1 + 1i,2 - 2i,3 + 3i'
+```
+
+<a name="method-with"></a>
+
+#### Complex128Array.prototype.with( index, value )
+
+Returns a new typed array with the element at a provided index replaced with a provided value.
+
+```javascript
+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 ], 1 );
+
+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
+```
 
 </section>
 
@@ -1060,7 +2289,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2023. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -1073,8 +2302,8 @@ Copyright &copy; 2016-2023. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/array-complex64.svg
 [npm-url]: https://npmjs.org/package/@stdlib/array-complex64
 
-[test-image]: https://github.com/stdlib-js/array-complex64/actions/workflows/test.yml/badge.svg?branch=v0.1.0
-[test-url]: https://github.com/stdlib-js/array-complex64/actions/workflows/test.yml?query=branch:v0.1.0
+[test-image]: https://github.com/stdlib-js/array-complex64/actions/workflows/test.yml/badge.svg?branch=v0.2.0
+[test-url]: https://github.com/stdlib-js/array-complex64/actions/workflows/test.yml?query=branch:v0.2.0
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/array-complex64/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/array-complex64?branch=main
@@ -1097,8 +2326,11 @@ Copyright &copy; 2016-2023. The Stdlib [Authors][stdlib-authors].
 [es-module]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules
 
 [deno-url]: https://github.com/stdlib-js/array-complex64/tree/deno
+[deno-readme]: https://github.com/stdlib-js/array-complex64/blob/deno/README.md
 [umd-url]: https://github.com/stdlib-js/array-complex64/tree/umd
+[umd-readme]: https://github.com/stdlib-js/array-complex64/blob/umd/README.md
 [esm-url]: https://github.com/stdlib-js/array-complex64/tree/esm
+[esm-readme]: https://github.com/stdlib-js/array-complex64/blob/esm/README.md
 [branches-url]: https://github.com/stdlib-js/array-complex64/blob/main/branches.md
 
 [stdlib-license]: https://raw.githubusercontent.com/stdlib-js/array-complex64/main/LICENSE