Auto-generated commit

Author: stdlib-bot

CHANGELOG.md

@@ -765,6 +765,7 @@ This release closes the following issue:
 
 ##### Features
 
+-   [`b68b283`](https://github.com/stdlib-js/stdlib/commit/b68b28358b19ba7e4d23d9a87acfb283c3c0ea3d) - add specialized support for complex number and boolean arrays
 -   [`c7f571e`](https://github.com/stdlib-js/stdlib/commit/c7f571ef00c124a120847f0c8fa59053c7c27dba) - add `array/base/index-of-same-value`
 
 </section>
@@ -1623,6 +1624,8 @@ A total of 13 people contributed to this release. Thank you to the following con
 
 <details>
 
+-   [`c7f060f`](https://github.com/stdlib-js/stdlib/commit/c7f060f6549d45a4c7faa06b25ff55a882ee6299) - **test:** add test cases _(by Athan Reines)_
+-   [`b68b283`](https://github.com/stdlib-js/stdlib/commit/b68b28358b19ba7e4d23d9a87acfb283c3c0ea3d) - **feat:** add specialized support for complex number and boolean arrays _(by Athan Reines)_
 -   [`e8bb580`](https://github.com/stdlib-js/stdlib/commit/e8bb580f445dcbeeb03e458def428d9e820ab808) - **feat:** add `lastIndexOfSameValue` to namespace _(by Athan Reines)_
 -   [`25fd7dd`](https://github.com/stdlib-js/stdlib/commit/25fd7dd71923e473865bb8c814fdef3981b17593) - **feat:** add `array/base/last-index-of-same-value` _(by Athan Reines)_
 -   [`e8a96a1`](https://github.com/stdlib-js/stdlib/commit/e8a96a17652f957f69c041a2f7292bee1b827aeb) - **feat:** add `indexOfSameValue` to namespace _(by Athan Reines)_

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>
 

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

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)

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( './../../../base/assert/is-complex-typed-array' );
+var isBooleanArray = require( './../../../base/assert/is-booleanarray' );
 var arraylike2object = require( './../../../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 );
 }
 
 

base/index-of-same-value/test/test.js

@@ -22,8 +22,11 @@
 
 var tape = require( 'tape' );
 var AccessorArray = require( './../../../base/accessor' );
+var Complex128Array = require( './../../../complex128' );
+var BooleanArray = require( './../../../bool' );
 var Float64Array = require( './../../../float64' );
 var Int32Array = require( './../../../int32' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var indexOfSameValue = require( './../lib' );
 
 
@@ -123,6 +126,96 @@ 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' );
+
+	// Non-complex values:
+	actual = indexOfSameValue( x, 1.0, 0 );
+	t.strictEqual( actual, -1, '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' );
+
+	// Non-boolean values:
+	actual = indexOfSameValue( x, 0, 0 );
+	t.strictEqual( actual, -1, '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;