@stdlib/array-complex64 0.0.6 → 0.2.0

package/README.md

@@ -18,6 +18,17 @@ limitations under the License.
 
 -->
 
+
+<details>
+  <summary>
+    About stdlib...
+  </summary>
+  <p>We believe in a future in which the web is a preferred environment for numerical computation. To help realize this future, we've built stdlib. stdlib is a standard library, with an emphasis on numerical and scientific computation, written in JavaScript (and C) for execution in browsers and in Node.js.</p>
+  <p>The library is fully decomposable, being architected in such a way that you can swap out and mix and match APIs and functionality to cater to your exact preferences and use cases.</p>
+  <p>When you use stdlib, you can be absolutely certain that you are using the most thorough, rigorous, well-written, studied, documented, tested, measured, and high-quality code out there.</p>
+  <p>To join us in bringing numerical computing to the web, get started by checking us out on <a href="https://github.com/stdlib-js/stdlib">GitHub</a>, and please consider <a href="https://opencollective.com/stdlib">financially supporting stdlib</a>. We greatly appreciate your continued support!</p>
+</details>
+
 # Complex64Array
 
 [![NPM version][npm-image]][npm-url] [![Build Status][test-image]][test-url] [![Coverage Status][coverage-image]][coverage-url] <!-- [![dependencies][dependencies-image]][dependencies-url] -->
@@ -526,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] )
@@ -760,263 +821,1443 @@ 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
-
-// Set the first element:
-arr.set( new Complex64( 1.0, -1.0 ) );
+// returns 1.0
 
-// Get the first element:
-z = arr.get( 0 );
+z = arr.get( 2 );
 // returns <Complex64>
 
 re = realf( z );
 // returns 1.0
 
 im = imagf( z );
-// returns -1.0
-```
+// 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`.
+// Fill all elements starting from the second element:
+arr.fill( new Complex64( 2.0, 2.0 ), 1 );
 
-```javascript
-var Complex64 = require( '@stdlib/complex-float32' );
-var realf = require( '@stdlib/complex-realf' );
-var imagf = require( '@stdlib/complex-imagf' );
+z = arr.get( 1 );
+// returns <Complex64>
 
-var arr = new Complex64Array( 10 );
+re = realf( z );
+// returns 2.0
 
-// Get the fifth element:
-var z = arr.get( 4 );
+im = imagf( z );
+// returns 2.0
+
+z = arr.get( 2 );
 // returns <Complex64>
 
-var re = realf( z );
-// returns 0.0
+re = realf( z );
+// returns 2.0
 
-var im = imagf( z );
-// returns 0.0
+im = imagf( z );
+// returns 2.0
 
-// Set the fifth element:
-arr.set( new Complex64( 1.0, -1.0 ), 4 );
+// Fill all elements from first element until the second-to-last element:
+arr.fill( new Complex64( 3.0, 3.0 ), 0, 2 );
 
-// Get the fifth element:
-z = arr.get( 4 );
+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
 ```
 
-In addition to providing a complex number, to set one or more array elements, provide an array-like object containing either complex numbers
+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 );
-
-// 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 all array elements, except the last element, to the same value:
+arr.fill( new Complex64( 1.0, 1.0 ), 0, -1 );
 
-// Get the sixth element:
-var z = arr.get( 5 );
+var z = arr.get( 0 );
 // returns <Complex64>
 
 var re = realf( z );
-// returns 2.0
+// returns 1.0
 
 var im = imagf( z );
-// returns -2.0
+// returns 1.0
+
+z = arr.get( arr.length - 1 );
+// returns <Complex64>
+
+re = realf( z );
+// returns 0.0
+
+im = imagf( z );
+// returns 0.0
 ```
 
-or interleaved real and imaginary components
+<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 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 ) {
+    return ( 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 );
+// 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
 ```
 
-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.
-
-</section>
-
-<!-- /.usage -->
+The `predicate` function is provided three arguments:
 
-<!-- Package usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
 
-<section class="notes">
+To set the function execution context, provide a `thisArg`.
 
-* * *
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
 
-## Notes
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
 
--   While a `Complex64Array` _strives_ to maintain (but does not **guarantee**) consistency with [typed arrays][@stdlib/array/typed], significant deviations from ECMAScript-defined [typed array][@stdlib/array/typed] behavior are as follows:
+var arr = new Complex64Array( 3 );
 
-    -   The constructor does **not** require the `new` operator.
-    -   The constructor and associated methods support a broader variety of input argument types in order to better accommodate complex number input.
-    -   Accessing array elements using bracket syntax (e.g., `Z[i]`) is **not** supported. Instead, one **must** use the `.get()` method which returns a value compatible with complex number output.
-    -   The `set` method has extended behavior in order to support complex numbers.
+var context = {
+    'count': 0
+};
 
-</section>
+// 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 );
 
-<!-- /.notes -->
+var out = arr.filter( predicate, context );
+// returns <Complex64Array>
 
-<!-- Package usage examples. -->
+var len = out.length;
+// returns 2
 
-<section class="examples">
+var count = context.count;
+// returns 3
+```
 
-* * *
+<a name="method-find"></a>
 
-## Examples
+#### Complex64Array.prototype.find( predicate\[, thisArg] )
 
-<!-- eslint no-undef: "error" -->
+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' );
-var Float32Array = require( '@stdlib/array-float32' );
-var Complex64Array = require( '@stdlib/array-complex64' );
 
-// Create a complex array by specifying a length:
-var out = new Complex64Array( 3 );
-console.log( out );
+function predicate( v ) {
+    return ( realf( v ) === imagf( v ) );
+}
 
-// Create a complex array from an array of complex numbers:
-var arr = [
-    new Complex64( 1.0, -1.0 ),
-    new Complex64( -3.14, 3.14 ),
-    new Complex64( 0.5, 0.5 )
-];
-out = new Complex64Array( arr );
-console.log( out );
+var arr = new Complex64Array( 3 );
 
-// Create a complex array from an interleaved typed array:
-arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
-out = new Complex64Array( arr );
-console.log( out );
+// 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 );
 
-// Create a complex array from an array buffer:
-arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
-out = new Complex64Array( arr.buffer );
-console.log( out );
+var z = arr.find( predicate );
+// returns <Complex64>
 
-// Create a complex array from an array buffer view:
-arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
-out = new Complex64Array( arr.buffer, 8, 2 );
-console.log( out );
+var re = realf( z );
+// returns 1.0
+
+var im = imagf( z );
+// returns 1.0
 ```
 
-</section>
+The `predicate` function is provided three arguments:
 
-<!-- /.examples -->
+-   **value**: current array element.
+-   **index**: current array element index.
+-   **arr**: the array on which this method was called.
 
-<!-- Section to include cited references. If references are included, add a horizontal rule *before* the section. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+To set the function execution context, provide a `thisArg`.
 
-<section class="references">
+```javascript
+var realf = require( '@stdlib/complex-realf' );
+var imagf = require( '@stdlib/complex-imagf' );
 
-</section>
+function predicate( v, i ) {
+    this.count += 1;
+    return ( i >= 0 && realf( v ) === imagf( v ) );
+}
 
-<!-- /.references -->
+var arr = new Complex64Array( 3 );
 
-<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+var context = {
+    'count': 0
+};
 
-<section class="related">
+// 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
+
+var count = context.count;
+// returns 2
+```
+
+<a name="method-find-index"></a>
+
+#### 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>
+
+<!-- /.usage -->
+
+<!-- Package usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+* * *
+
+## Notes
+
+-   While a `Complex64Array` _strives_ to maintain (but does not **guarantee**) consistency with [typed arrays][@stdlib/array/typed], significant deviations from ECMAScript-defined [typed array][@stdlib/array/typed] behavior are as follows:
+
+    -   The constructor does **not** require the `new` operator.
+    -   The constructor and associated methods support a broader variety of input argument types in order to better accommodate complex number input.
+    -   Accessing array elements using bracket syntax (e.g., `Z[i]`) is **not** supported. Instead, one **must** use the `.get()` method which returns a value compatible with complex number output.
+    -   The `set` method has extended behavior in order to support complex numbers.
+
+</section>
+
+<!-- /.notes -->
+
+<!-- Package usage examples. -->
+
+<section class="examples">
+
+* * *
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var Complex64 = require( '@stdlib/complex-float32' );
+var Float32Array = require( '@stdlib/array-float32' );
+var logEach = require( '@stdlib/console-log-each' );
+var Complex64Array = require( '@stdlib/array-complex64' );
+
+// Create a complex array by specifying a length:
+var out = new Complex64Array( 3 );
+logEach( '%s', out );
+
+// Create a complex array from an array of complex numbers:
+var arr = [
+    new Complex64( 1.0, -1.0 ),
+    new Complex64( -3.14, 3.14 ),
+    new Complex64( 0.5, 0.5 )
+];
+out = new Complex64Array( arr );
+logEach( '%s', out );
+
+// Create a complex array from an interleaved typed array:
+arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
+out = new Complex64Array( arr );
+logEach( '%s', out );
+
+// Create a complex array from an array buffer:
+arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
+out = new Complex64Array( arr.buffer );
+logEach( '%s', out );
+
+// Create a complex array from an array buffer view:
+arr = new Float32Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
+out = new Complex64Array( arr.buffer, 8, 2 );
+logEach( '%s', out );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section to include cited references. If references are included, add a horizontal rule *before* the section. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="references">
+
+</section>
+
+<!-- /.references -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
 
 * * *
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/array/complex128`][@stdlib/array/complex128]</span><span class="delimiter">: </span><span class="description">Complex128Array.</span>
--   <span class="package-name">[`@stdlib/complex/cmplx`][@stdlib/complex/cmplx]</span><span class="delimiter">: </span><span class="description">create a complex number.</span>
--   <span class="package-name">[`@stdlib/complex/float32`][@stdlib/complex/float32]</span><span class="delimiter">: </span><span class="description">64-bit complex number.</span>
+-   <span class="package-name">[`@stdlib/array-complex128`][@stdlib/array/complex128]</span><span class="delimiter">: </span><span class="description">Complex128Array.</span>
+-   <span class="package-name">[`@stdlib/complex-cmplx`][@stdlib/complex/cmplx]</span><span class="delimiter">: </span><span class="description">create a complex number.</span>
+-   <span class="package-name">[`@stdlib/complex-float32`][@stdlib/complex/float32]</span><span class="delimiter">: </span><span class="description">64-bit complex number.</span>
 
 </section>
 
@@ -1048,7 +2289,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -1061,8 +2302,8 @@ Copyright &copy; 2016-2022. 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
-[test-url]: https://github.com/stdlib-js/array-complex64/actions/workflows/test.yml
+[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
@@ -1074,19 +2315,23 @@ Copyright &copy; 2016-2022. The Stdlib [Authors][stdlib-authors].
 
 -->
 
+[chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
+[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
+
+[stdlib]: https://github.com/stdlib-js/stdlib
+
+[stdlib-authors]: https://github.com/stdlib-js/stdlib/graphs/contributors
+
 [umd]: https://github.com/umdjs/umd
 [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
-
-[chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://gitter.im/stdlib-js/stdlib/
-
-[stdlib]: https://github.com/stdlib-js/stdlib
-
-[stdlib-authors]: https://github.com/stdlib-js/stdlib/graphs/contributors
+[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