feat: add specialized support for complex number and boolean arrays

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/array/base/index-of-same-value/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # indexOfSameValue
 
-> Return the index of the first element which equals a provided search element according to the [same value algorithm][@stdlib/assert/is-same-value].
+> Return the index of the first element which equals a provided search element according to the [SameValue Algorithm][@stdlib/assert/is-same-value].
 
 <!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
 
@@ -42,7 +42,7 @@ var indexOfSameValue = require( '@stdlib/array/base/index-of-same-value' );
 
 #### indexOfSameValue( x, searchElement, fromIndex )
 
-Returns the index of the first element which equals a provided search element according to the [same value algorithm][@stdlib/assert/is-same-value].
+Returns the index of the first element which equals a provided search element according to the [SameValue Algorithm][@stdlib/assert/is-same-value].
 
 ```javascript
 var x = [ 1, 2, 3, 4, 5, 6 ];
@@ -89,7 +89,7 @@ var idx = indexOfSameValue( x, 2, -4 );
 ## Notes
 
 -   The function performs a linear scan and returns immediately upon finding a match.
--   When searching for a search element, the function checks for equality using the [same value algorithm][@stdlib/assert/is-same-value]. As a consequence, `NaN` values are considered equal, and `-0` and `+0` are considered distinct.
+-   When searching for a search element, the function checks for equality using the [SameValue Algorithm][@stdlib/assert/is-same-value] as specified in ECMAScript 5. As a consequence, `NaN` values are considered equal, and `-0` and `+0` are considered distinct.
 
 </section>
 

lib/node_modules/@stdlib/array/base/index-of-same-value/docs/repl.txt

@@ -9,6 +9,8 @@
     If unable to find an element which equals a provided search element, the
     function returns -1.
 
+    The function treats `-0` and `+0` as distinct and `NaNs` as the same.
+
     Parameters
     ----------
     x: ArrayLikeObject

lib/node_modules/@stdlib/array/base/index-of-same-value/docs/types/index.d.ts

@@ -27,9 +27,13 @@ import { Collection, AccessorArrayLike } from '@stdlib/types/array';
 *
 * ## Notes
 *
+* -   The function uses the [SameValue Algorithm][ecma-262-same-value-algorithm], as specified in ECMAScript 5.
+* -   In contrast to the strict equality operator `===`, `-0` and `+0` are distinguishable and `NaNs` are the same.
 * -   If unable to find an element which equals a provided search element, the function returns `-1`.
 * -   If `fromIndex` is less than zero, the starting index is resolved relative to the last array element, with the last array element corresponding to `fromIndex = -1`.
 *
+* [ecma-262-same-value-algorithm]: http://ecma-international.org/ecma-262/5.1/#sec-9.12
+*
 * @param x - input array
 * @param searchElement - search element
 * @param fromIndex - starting index (inclusive)

lib/node_modules/@stdlib/array/base/index-of-same-value/lib/main.js

@@ -20,8 +20,16 @@
 
 // MODULES //
 
+var isComplexLike = require( '@stdlib/assert/is-complex-like' );
+var isBoolean = require( '@stdlib/assert/is-boolean' ).isPrimitive;
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex' );
+var reinterpretBoolean = require( '@stdlib/strided/base/reinterpret-boolean' );
+var isComplexTypedArray = require( '@stdlib/array/base/assert/is-complex-typed-array' );
+var isBooleanArray = require( '@stdlib/array/base/assert/is-booleanarray' );
 var arraylike2object = require( '@stdlib/array/base/arraylike2object' );
 var isSameValue = require( '@stdlib/assert/is-same-value' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
 
 
 // FUNCTIONS //
@@ -38,10 +46,10 @@ var isSameValue = require( '@stdlib/assert/is-same-value' );
 * @example
 * var x = [ 1, 2, 3, 4 ];
 *
-* var idx = internal( x, 2, 0 );
+* var idx = indexed( x, 2, 0 );
 * // returns 1
 */
-function internal( x, searchElement, fromIndex ) {
+function indexed( x, searchElement, fromIndex ) {
 	var i;
 	for ( i = fromIndex; i < x.length; i++ ) {
 		if ( isSameValue( searchElement, x[ i ] ) ) {
@@ -85,6 +93,77 @@ function accessors( x, searchElement, fromIndex ) {
 	return -1;
 }
 
+/**
+* Returns the index of the first element which equals a provided search element according to the same value algorithm.
+*
+* @private
+* @param {Collection} x - input array
+* @param {*} searchElement - search element
+* @param {NonNegativeInteger} fromIndex - starting index (inclusive)
+* @returns {integer} index
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var Complex128 = require( '@stdlib/complex/float64/ctor' );
+*
+* var x = new Complex128Array( [ 1.0, 2.0, 0.0, 0.0, 3.0, 4.0, 0.0, 0.0 ] );
+*
+* var idx = complex( x, new Complex128( 3.0, 4.0 ), 1 );
+* // returns 2
+*/
+function complex( x, searchElement, fromIndex ) {
+	var view;
+	var re;
+	var im;
+	var i;
+	if ( !isComplexLike( searchElement ) ) {
+		return -1;
+	}
+	view = reinterpret( x, 0 );
+	re = real( searchElement );
+	im = imag( searchElement );
+	for ( i = fromIndex*2; i < view.length; i += 2 ) {
+		if ( isSameValue( view[ i ], re ) && isSameValue( view[ i+1 ], im ) ) {
+			return i / 2;
+		}
+	}
+	return -1;
+}
+
+/**
+* Returns the index of the first element which equals a provided search element according to the same value algorithm.
+*
+* @private
+* @param {Collection} x - input array
+* @param {*} searchElement - search element
+* @param {NonNegativeInteger} fromIndex - starting index (inclusive)
+* @returns {integer} index
+*
+* @example
+* var BooleanArray = require( '@stdlib/array/bool' );
+*
+* var x = new BooleanArray( [ true, false, true, false, true ] );
+*
+* var idx = boolean( x, true, 1 );
+* // returns 2
+*/
+function boolean( x, searchElement, fromIndex ) {
+	var view;
+	var v;
+	var i;
+	if ( !isBoolean( searchElement ) ) {
+		return -1;
+	}
+	view = reinterpretBoolean( x, 0 );
+	v = ( searchElement ) ? 1 : 0;
+	for ( i = fromIndex; i < view.length; i++ ) {
+		if ( view[ i ] === v ) {
+			return i;
+		}
+	}
+	return -1;
+}
+
 
 // MAIN //
 
@@ -93,8 +172,12 @@ function accessors( x, searchElement, fromIndex ) {
 *
 * ## Notes
 *
+* -   The function uses the [SameValue Algorithm][ecma-262-same-value-algorithm], as specified in ECMAScript 5.
+* -   In contrast to the strict equality operator `===`, `-0` and `+0` are distinguishable and `NaNs` are the same.
 * -   If unable to find an element which equals a provided search element, the function returns `-1`.
 *
+* [ecma-262-same-value-algorithm]: http://ecma-international.org/ecma-262/5.1/#sec-9.12
+*
 * @param {Collection} x - input array
 * @param {*} searchElement - search element
 * @param {integer} fromIndex - starting index (inclusive)
@@ -124,9 +207,15 @@ function indexOfSameValue( x, searchElement, fromIndex ) {
 	}
 	obj = arraylike2object( x );
 	if ( obj.accessorProtocol ) {
+		if ( isComplexTypedArray( x ) ) {
+			return complex( x, searchElement, fromIndex );
+		}
+		if ( isBooleanArray( x ) ) {
+			return boolean( x, searchElement, fromIndex );
+		}
 		return accessors( obj, searchElement, fromIndex );
 	}
-	return internal( x, searchElement, fromIndex );
+	return indexed( x, searchElement, fromIndex );
 }
 
 

lib/node_modules/@stdlib/array/base/index-of-same-value/test/test.js

@@ -22,8 +22,11 @@
 
 var tape = require( 'tape' );
 var AccessorArray = require( '@stdlib/array/base/accessor' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var BooleanArray = require( '@stdlib/array/bool' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Int32Array = require( '@stdlib/array/int32' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var indexOfSameValue = require( './../lib' );
 
 
@@ -123,6 +126,88 @@ tape( 'the function returns the first index of an element which equals a provide
 	t.end();
 });
 
+tape( 'the function returns the first index of an element which equals a provided search element (complex128)', function test( t ) {
+	var actual;
+	var x;
+
+	x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0 ] ); // eslint-disable-line max-len
+
+	actual = indexOfSameValue( x, new Complex128( 1.0, 1.0 ), 0 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 2.0, 2.0 ), 0 );
+	t.strictEqual( actual, 2, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 3.0, 3.0 ), 0 );
+	t.strictEqual( actual, 4, 'returns expected value' );
+
+	// Nonnegative starting index...
+	actual = indexOfSameValue( x, new Complex128( 1.0, 1.0 ), 1 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 2.0, 2.0 ), 3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 3.0, 3.0 ), 5 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	// Negative starting index...
+	actual = indexOfSameValue( x, new Complex128( 1.0, 1.0 ), -10 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 3.0, 3.0 ), -10 );
+	t.strictEqual( actual, 4, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 1.0, 1.0 ), -5 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 2.0, 2.0 ), -3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = indexOfSameValue( x, new Complex128( 3.0, 3.0 ), -1 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns the first index of an element which equals a provided search element (bool)', function test( t ) {
+	var actual;
+	var x;
+
+	x = new BooleanArray( [ true, true, false, false, true, true ] );
+
+	actual = indexOfSameValue( x, true, 0 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = indexOfSameValue( x, false, 0 );
+	t.strictEqual( actual, 2, 'returns expected value' );
+
+	// Nonnegative starting index...
+	actual = indexOfSameValue( x, true, 1 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = indexOfSameValue( x, false, 3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = indexOfSameValue( x, true, 5 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	// Negative starting index...
+	actual = indexOfSameValue( x, true, -10 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = indexOfSameValue( x, true, -5 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = indexOfSameValue( x, false, -3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = indexOfSameValue( x, true, -1 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function returns the first index of an element which equals a provided search element (int32)', function test( t ) {
 	var actual;
 	var x;