fix(lib/node_modules/@stdlib/iter/cartesian-square): resolved issues …

…with the package

Signed-off-by: vinayak <fobo401@gmail.com>

lib/node_modules/@stdlib/iter/cartesian-square/README.md

@@ -39,13 +39,22 @@ var iterCartesianSquare = require( '@stdlib/iter/cartesian-square' );
 Returns an iterator which generates the Cartesian Square of an input array-like object.
 
 ```javascript
-var x = ['a', 'b', 'c'];
-var pair;
-var cartesianSquare = iterCartesianSquare( x, n );
+var it = iterCartesianSquare( [ 1, 2, 3 ] );
 
-for ( pair of cartesianSquare ) {
-    console.log( pair );
-}
+var v = it.next().value;
+// returns [1, 1]
+
+v = it.next().value;
+// returns [1, 2]
+
+v = it.next().value;
+// returns [1, 3]
+
+v = it.next().value;
+// returns [2, 1]
+
+var bool = it.next().done;
+// returns false
 
 ```
 
@@ -57,11 +66,6 @@ for ( pair of cartesianSquare ) {
 
 <section class="notes">
 
-## Notes
-
-The function expects only one argument x, an array-like object.
-The returned iterator will generate all possible combinations from the input array x.
-
 </section>
 
 <!-- /.notes -->
@@ -81,8 +85,10 @@ var x = [1, 2, 3];
 var cartesianSquare = iterCartesianSquare( x );
 var pair;
 
-for ( pair of cartesianSquare ) {
-    console.log( pair );
+pair = cartesianSquare.next();
+while ( !pair.done ) {
+    console.log( pair.value );
+    pair = cartesianSquare.next();
 }
 
 // Output:

lib/node_modules/@stdlib/iter/cartesian-square/benchmark/benchmark.js

@@ -22,6 +22,8 @@
 // MODULES //
 
 var bench = require('@stdlib/bench');
+var ceil = require('@stdlib/math/base/special/ceil');
+var sqrt = require('@stdlib/math/base/special/sqrt');
 var pkg = require('./../package.json').name;
 var iterCartesianSquare = require('./../lib');
 
@@ -30,30 +32,30 @@ var iterCartesianSquare = require('./../lib');
 
 bench( pkg, function benchmark( b ) {
 	var iterator;
-	var arr = ['a', 'b', 'c'];
+	var arr;
 	var v;
 	var i;
 
-	// Run the benchmark...
+	// Create an array with one more element than the square root of b.iterations:
+	arr = new Array( ceil(sqrt(b.iterations)) + 1 ).fill( 0 );
+
+	// Create the iterator:
+	iterator = iterCartesianSquare( arr );
+
 	b.tic();
-	for (i = 0; i < b.iterations; i++) {
-		// Reset the iterator:
-		iterator = iterCartesianSquare(arr);
+	for ( i = 0; i < b.iterations; i++ ) {
 		v = iterator.next();
-
-		// Iterate over the Cartesian square:
-		while (!v.done) {
-			if (v.done) {
-				b.fail('should iterate over all elements');
-			}
-			v = iterator.next();
+		if ( v.done ) {
+			b.fail( 'should not exhaust the iterator' );
+			break;
 		}
 	}
 	b.toc();
-	if (v.done) {
-		b.pass('benchmark finished');
+
+	if ( v.done ) {
+		b.fail('should not exhaust the iterator');
 	} else {
-		b.fail('should have finished iteration');
+		b.pass('benchmark finished');
 	}
 	b.end();
 });

lib/node_modules/@stdlib/iter/cartesian-square/docs/repl.txt

@@ -1,11 +1,13 @@
 {{alias}}( x )
     Returns an iterator which generates the Cartesian square of an input
-    array-like object. If an environment supports Symbol.iterator, the returned
-    iterator is iterable.
+    array-like object. 
+
+    If an environment supports Symbol.iterator, the returned iterator is 
+    iterable.
 
     Parameters
     ----------
-     x : collection
+     x : ArrayLikeObject
         Input array-like object.
 
     Returns

lib/node_modules/@stdlib/iter/cartesian-square/docs/types/index.d.ts

@@ -53,7 +53,8 @@ type Iterator = Iter | IterableIterator;
 * var bool = iterator.next().done;
 * // returns true
 */
-declare function iterCartesianSquare<T>( x: ArrayLike<T> | Iterable<T> ): Iterator;
+declare function iterCartesianSquare<T>( x: ArrayLike<T> ): Iterator;
+
 
 // EXPORTS //
 

lib/node_modules/@stdlib/iter/cartesian-square/lib/main.js

@@ -23,14 +23,16 @@
 var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
 var iteratorSymbol = require( '@stdlib/symbol/iterator' );
 var floor = require( '@stdlib/math/base/special/floor' );
+var isCollection = require('@stdlib/assert/is-collection');
+var resolveGetter = require( '@stdlib/array/base/resolve-getter' );
 
 
 // MAIN //
 
 /**
 * Returns an iterator which generates the Cartesian square of an input array-like object.
 *
-* @param {ArrayLike} arr - input array
+* @param {Collection} arr - input array
 * @throws {TypeError} must provide an array-like object
 * @returns {Iterator} iterator
 *
@@ -48,11 +50,15 @@ var floor = require( '@stdlib/math/base/special/floor' );
 function iterCartesianSquare( arr ) {
 	var iter;
 	var FLG;
+	var get;
 	var i;
 
-	if ( !Array.isArray( arr ) ) {
+	if ( !isCollection( arr ) ) {
 		throw new TypeError( 'invalid argument. Must provide an array-like object. Value: `' + arr + '`.' );
 	}
+
+	get = resolveGetter( arr );
+
 	iter = {};
 	FLG = false;
 	i = 0;
@@ -63,22 +69,23 @@ function iterCartesianSquare( arr ) {
 		setReadOnly( iter, iteratorSymbol, factory );
 	}
 	return iter;
-
 	/**
 	* Returns an iterator protocol-compliant object containing the next iterated value.
-* @private
-* @returns {Object} iterator result
-*/
+	* @private
+	* @returns {Object} iterator result
+	*/
 	function next() {
 		var v;
+		var N;
 		if ( FLG ) {
 			return {
 				'done': true
 			};
 		}
-		v = [ arr[ floor( i / arr.length ) ], arr[ i % arr.length ] ];
+		N = arr.length * arr.length;
+		v = [get(arr, floor(i / arr.length)), get(arr, i % arr.length)];
 		i += 1;
-		if ( i >= arr.length * arr.length ) {
+		if ( i >= N ) {
 			FLG = true;
 		}
 		return {
@@ -89,9 +96,9 @@ function iterCartesianSquare( arr ) {
 
 	/**
 	* Finishes an iterator.
-* @private
-* @returns {Object} iterator result
-*/
+	* @private
+	* @returns {Object} iterator result
+	*/
 	function finish() {
 		FLG = true;
 		return {
@@ -101,9 +108,9 @@ function iterCartesianSquare( arr ) {
 
 	/**
 	* Returns a new iterator.
-* @private
-* @returns {Iterator} iterator
-*/
+	* @private
+	* @returns {Iterator} iterator
+	*/
 	function factory() {
 		return iterCartesianSquare( arr );
 	}

lib/node_modules/@stdlib/iter/cartesian-square/test/test.js

@@ -85,7 +85,49 @@ tape( 'the function returns an iterator which generates the Cartesian square of
 	actual = iter.next().value;
 	t.deepEqual( actual, expected, 'returns expected value' );
 
-	t.ok( iter.next().done, 'returns expected value' );
+	t.strictEqual( iter.next().done, true, 'returns expected value' );
 
 	t.end();
 });
+
+tape('the finish function returns an object with done property set to true', function test(t) {
+	var iterator = iterCartesianSquare([1, 2]);
+	var result;
+	iterator.next(); // consume a value to ensure the iterator is not at the start
+	result = iterator.return(); // call the finish function
+	t.deepEqual(result, {
+		'done': true
+	}, 'returns expected value');
+	t.end();
+});
+
+tape('the factory function returns a new iterator', function test(t) {
+	var iterator1 = iterCartesianSquare([1, 2]);
+	var iterator2 = iterator1[Symbol.iterator](); // call the factory function
+	t.notEqual(iterator1, iterator2, 'returns new iterator');
+	t.end();
+});
+
+tape('the factory function returns an iterator that generates the same sequence', function test(t) {
+	var iterator1 = iterCartesianSquare([1, 2]);
+	var iterator2 = iterator1[Symbol.iterator](); // call the factory function
+	var result1 = [];
+	var result2 = [];
+	var next1;
+	var next2;
+
+	next1 = iterator1.next();
+	while (!next1.done) {
+		result1.push(next1.value);
+		next1 = iterator1.next();
+	}
+
+	next2 = iterator2.next();
+	while (!next2.done) {
+		result2.push(next2.value);
+		next2 = iterator2.next();
+	}
+
+	t.deepEqual(result1, result2, 'returns iterator that generates the same sequence');
+	t.end();
+});