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/last-index-of-same-value/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # lastIndexOfSameValue
 
-> Return the index of the last element which equals a provided search element according to the [same value algorithm][@stdlib/assert/is-same-value].
+> Return the index of the last 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 lastIndexOfSameValue = require( '@stdlib/array/base/last-index-of-same-value
 
 #### lastIndexOfSameValue( x, searchElement, fromIndex )
 
-Returns the index of the last element which equals a provided search element according to the [same value algorithm][@stdlib/assert/is-same-value].
+Returns the index of the last 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 = lastIndexOfSameValue( x, 2, -4 );
 ## Notes
 
 -   The function scans an input array from the starting index to the beginning of the array (i.e., backward).
--   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/last-index-of-same-value/docs/repl.txt

@@ -12,6 +12,8 @@
     The function scans an input array from the starting index to the beginning
     of the array (i.e., backward).
 
+    The function treats `-0` and `+0` as distinct and `NaNs` as the same.
+
     Parameters
     ----------
     x: ArrayLikeObject

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

@@ -27,10 +27,14 @@ 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.
 * -   The function scans an input array from the starting index to the beginning of the array (i.e., backward).
 * -   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/last-index-of-same-value/lib/main.js

@@ -20,8 +20,17 @@
 
 // MODULES //
 
-var arraylike2object = require( '@stdlib/array/base/arraylike2object' );
+var isAccessorArray = require( '@stdlib/assert/is-accessor-array' );
+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 resolveGetter = require( '@stdlib/array/base/resolve-getter' );
 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 +47,10 @@ var isSameValue = require( '@stdlib/assert/is-same-value' );
 * @example
 * var x = [ 1, 2, 3, 4 ];
 *
-* var idx = internal( x, 2, 3 );
+* var idx = indexed( x, 2, 3 );
 * // returns 1
 */
-function internal( x, searchElement, fromIndex ) {
+function indexed( x, searchElement, fromIndex ) {
 	var i;
 	for ( i = fromIndex; i >= 0; i-- ) {
 		if ( isSameValue( searchElement, x[ i ] ) ) {
@@ -62,23 +71,90 @@ function internal( x, searchElement, fromIndex ) {
 *
 * @example
 * var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
-* var arraylike2object = require( '@stdlib/array/base/arraylike2object' );
 *
-* var x = arraylike2object( toAccessorArray( [ 1, 2, 3, 4 ] ) );
+* var x = toAccessorArray( [ 1, 2, 3, 4 ] );
 *
 * var idx = accessors( x, 2, 3 );
 * // returns 1
 */
 function accessors( x, searchElement, fromIndex ) {
-	var data;
 	var get;
 	var i;
 
-	data = x.data;
-	get = x.accessors[ 0 ];
+	get = resolveGetter( x );
+	for ( i = fromIndex; i >= 0; i-- ) {
+		if ( isSameValue( searchElement, get( x, i ) ) ) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+/**
+* Returns the index of the last 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 ), 3 );
+* // 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 >= 0; i -= 2 ) {
+		if ( isSameValue( view[ i ], re ) && isSameValue( view[ i+1 ], im ) ) {
+			return i / 2;
+		}
+	}
+	return -1;
+}
 
+/**
+* Returns the index of the last 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, 3 );
+* // 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 >= 0; i-- ) {
-		if ( isSameValue( searchElement, get( data, i ) ) ) {
+		if ( view[ i ] === v ) {
 			return i;
 		}
 	}
@@ -93,8 +169,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)
@@ -115,7 +195,6 @@ function accessors( x, searchElement, fromIndex ) {
 * // returns 1
 */
 function lastIndexOfSameValue( x, searchElement, fromIndex ) {
-	var obj;
 	if ( fromIndex < 0 ) {
 		fromIndex += x.length;
 		if ( fromIndex < 0 ) {
@@ -124,11 +203,16 @@ function lastIndexOfSameValue( x, searchElement, fromIndex ) {
 	} else if ( fromIndex > x.length ) {
 		fromIndex = x.length - 1;
 	}
-	obj = arraylike2object( x );
-	if ( obj.accessorProtocol ) {
-		return accessors( obj, searchElement, fromIndex );
+	if ( isAccessorArray( x ) ) {
+		if ( isComplexTypedArray( x ) ) {
+			return complex( x, searchElement, fromIndex );
+		}
+		if ( isBooleanArray( x ) ) {
+			return boolean( x, searchElement, fromIndex );
+		}
+		return accessors( x, searchElement, fromIndex );
 	}
-	return internal( x, searchElement, fromIndex );
+	return indexed( x, searchElement, fromIndex );
 }
 
 

lib/node_modules/@stdlib/array/base/last-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 lastIndexOfSameValue = require( './../lib' );
 
 
@@ -129,6 +132,102 @@ tape( 'the function returns the last index of an element which equals a provided
 	t.end();
 });
 
+tape( 'the function returns the last 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 = lastIndexOfSameValue( x, new Complex128( 1.0, 1.0 ), 5 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 2.0, 2.0 ), 5 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 3.0, 3.0 ), 5 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 2.0, 2.0 ), 1 );
+	t.strictEqual( actual, -1, 'returns expected value' );
+
+	// Nonnegative starting index...
+	actual = lastIndexOfSameValue( x, new Complex128( 1.0, 1.0 ), 0 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 2.0, 2.0 ), 2 );
+	t.strictEqual( actual, 2, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 3.0, 3.0 ), 4 );
+	t.strictEqual( actual, 4, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 3.0, 3.0 ), 100 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	// Negative starting index...
+	actual = lastIndexOfSameValue( x, new Complex128( 1.0, 1.0 ), -1 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 3.0, 3.0 ), -2 );
+	t.strictEqual( actual, 4, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 1.0, 1.0 ), -5 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 2.0, 2.0 ), -3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, new Complex128( 3.0, 3.0 ), -1 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	// Non-complex values:
+	actual = lastIndexOfSameValue( x, 1.0, 0 );
+	t.strictEqual( actual, -1, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns the last 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 = lastIndexOfSameValue( x, true, 5 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, false, 2 );
+	t.strictEqual( actual, 2, 'returns expected value' );
+
+	// Nonnegative starting index...
+	actual = lastIndexOfSameValue( x, true, 0 );
+	t.strictEqual( actual, 0, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, false, 2 );
+	t.strictEqual( actual, 2, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, true, 4 );
+	t.strictEqual( actual, 4, 'returns expected value' );
+
+	// Negative starting index...
+	actual = lastIndexOfSameValue( x, true, -1 );
+	t.strictEqual( actual, 5, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, true, -3 );
+	t.strictEqual( actual, 1, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, false, -5 );
+	t.strictEqual( actual, -1, 'returns expected value' );
+
+	actual = lastIndexOfSameValue( x, false, -3 );
+	t.strictEqual( actual, 3, 'returns expected value' );
+
+	// Non-boolean values:
+	actual = lastIndexOfSameValue( x, 0, 0 );
+	t.strictEqual( actual, -1, 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function returns the last index of an element which equals a provided search element (int32)', function test( t ) {
 	var actual;
 	var x;