Auto-generated commit

Author: stdlib-bot

CHANGELOG.md

@@ -689,6 +689,7 @@ A total of 38 issues were closed in this release:
 
 <details>
 
+-   [`016b07f`](https://github.com/stdlib-js/stdlib/commit/016b07f8610e21332af7bfbc38afbacdbeac8583) - **refactor:** rename/reorder parameters _(by Athan Reines)_
 -   [`5f0a844`](https://github.com/stdlib-js/stdlib/commit/5f0a844380510aaa97c8ca7d1b539868132ae2e7) - **refactor:** rename/reorder parameters _(by Athan Reines)_
 -   [`f40ccb7`](https://github.com/stdlib-js/stdlib/commit/f40ccb75929e92538b8c366145589addccdaafbe) - **feat:** add `ndarray/base/ternary-loop-interchange-order` [(#9499)](https://github.com/stdlib-js/stdlib/pull/9499) _(by Muhammad Haris, Athan Reines)_
 -   [`1f79854`](https://github.com/stdlib-js/stdlib/commit/1f798549409c47de0261c5396dccf64012e54a9c) - **feat:** add `ndarray/base/ternary-tiling-block-size` [(#9495)](https://github.com/stdlib-js/stdlib/pull/9495) _(by Muhammad Haris, Athan Reines)_

base/ternary-loop-interchange-order/README.md

@@ -40,7 +40,7 @@ limitations under the License.
 var ternaryLoopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
 ```
 
-#### ternaryLoopOrder( shape, stridesW, stridesX, stridesY, stridesZ )
+#### ternaryLoopOrder( shape, stridesX, stridesY, stridesZ, stridesW )
 
 Reorders [ndarray][@stdlib/ndarray/ctor] dimensions and associated strides for [loop interchange][loop-interchange].
 
@@ -49,25 +49,25 @@ Reorders [ndarray][@stdlib/ndarray/ctor] dimensions and associated strides for [
 var shape = [ 2, 2 ];
 
 // Define the strides for the input arrays:
-var stridesW = [ 2, 1 ]; // row-major
-var stridesX = [ 4, 2 ]; // row-major
-var stridesY = [ 1, 2 ]; // column-major
+var stridesX = [ 2, 1 ]; // row-major
+var stridesY = [ 4, 2 ]; // row-major
+var stridesZ = [ 1, 2 ]; // column-major
 
 // Define the strides for the output array:
-var stridesZ = [ 1, 2 ]; // column-major
+var stridesW = [ 1, 2 ]; // column-major
 
 // Resolve the loop interchange order:
-var o = ternaryLoopOrder( shape, stridesW, stridesX, stridesY, stridesZ );
+var o = ternaryLoopOrder( shape, stridesX, stridesY, stridesZ, stridesW );
 // returns {...}
 ```
 
 The function returns an object having the following properties:
 
 -   **sh**: ordered dimensions.
--   **sw**: first input array strides sorted in loop order.
--   **sx**: second input array strides sorted in loop order.
--   **sy**: third input array strides sorted in loop order.
--   **sz**: output array strides sorted in loop order.
+-   **sx**: first input array strides sorted in loop order.
+-   **sy**: second input array strides sorted in loop order.
+-   **sz**: third input array strides sorted in loop order.
+-   **sw**: output array strides sorted in loop order.
 
 For all returned arrays, the first element corresponds to the innermost loop, and the last element corresponds to the outermost loop.
 
@@ -110,13 +110,13 @@ var getStrides = require( '@stdlib/ndarray/strides' );
 var ternaryLoopOrder = require( '@stdlib/ndarray/base/binary-loop-interchange-order' );
 
 // Create ndarrays:
-var w = array( [ [ 1, 2 ], [ 3, 4 ] ] );
-var x = array( [ [ 5, 6 ], [ 7, 8 ] ] );
-var y = array( [ [ 9, 10 ], [ 11, 12 ] ] );
-var z = array( [ [ 0, 0 ], [ 0, 0 ] ] );
+var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+var y = array( [ [ 5, 6 ], [ 7, 8 ] ] );
+var z = array( [ [ 9, 10 ], [ 11, 12 ] ] );
+var w = array( [ [ 0, 0 ], [ 0, 0 ] ] );
 
 // Resolve loop interchange data:
-var o = ternaryLoopOrder( getShape( w ), getStrides( w ), getStrides( x ), getStrides( y ), getStrides( z ) );
+var o = ternaryLoopOrder( getShape( x ), getStrides( x ), getStrides( y ), getStrides( z ), getStrides( w ) );
 // returns {...}
 
 console.log( o );

base/ternary-loop-interchange-order/benchmark/benchmark.js

@@ -23,13 +23,14 @@
 var bench = require( '@stdlib/bench' );
 var isArray = require( '@stdlib/assert/is-array' );
 var shape2strides = require( './../../../base/shape2strides' );
+var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var ternaryLoopOrder = require( './../lib' );
 
 
 // MAIN //
 
-bench( pkg+'::row-major', function benchmark( b ) {
+bench( format( '%s::row-major', pkg ), function benchmark( b ) {
 	var strides;
 	var factors;
 	var shape;
@@ -52,14 +53,20 @@ bench( pkg+'::row-major', function benchmark( b ) {
 		}
 	}
 	b.toc();
-	if ( !isArray( out.sh ) || !isArray( out.sx ) || !isArray( out.sy ) || !isArray( out.sz ) ) { // eslint-disable-line max-len
+	if (
+		!isArray( out.sh ) ||
+		!isArray( out.sx ) ||
+		!isArray( out.sy ) ||
+		!isArray( out.sz ) ||
+		!isArray( out.sw )
+	) {
 		b.fail( 'should return an array' );
 	}
 	b.pass( 'benchmark finished' );
 	b.end();
 });
 
-bench( pkg+'::column-major', function benchmark( b ) {
+bench( format( '%s::column-major', pkg ), function benchmark( b ) {
 	var strides;
 	var factors;
 	var shape;
@@ -82,7 +89,13 @@ bench( pkg+'::column-major', function benchmark( b ) {
 		}
 	}
 	b.toc();
-	if ( !isArray( out.sh ) || !isArray( out.sx ) || !isArray( out.sy ) || !isArray( out.sz ) ) { // eslint-disable-line max-len
+	if (
+		!isArray( out.sh ) ||
+		!isArray( out.sx ) ||
+		!isArray( out.sy ) ||
+		!isArray( out.sz ) ||
+		!isArray( out.sw )
+	) {
 		b.fail( 'should return an array' );
 	}
 	b.pass( 'benchmark finished' );

base/ternary-loop-interchange-order/docs/repl.txt

@@ -1,14 +1,14 @@
 
-{{alias}}( shape, stridesW, stridesX, stridesY, stridesZ )
+{{alias}}( shape, stridesX, stridesY, stridesZ, stridesW )
     Reorders ndarray dimensions and associated strides for loop interchange.
 
     The function returns an object having the following properties:
 
     - sh: ordered dimensions.
-    - sw: first input array strides sorted in loop order.
-    - sx: second input array strides sorted in loop order.
-    - sy: third input array strides sorted in loop order.
-    - sz: output array strides sorted in loop order.
+    - sx: first input array strides sorted in loop order.
+    - sy: second input array strides sorted in loop order.
+    - sz: third input array strides sorted in loop order.
+    - sw: output array strides sorted in loop order.
 
     For all returned arrays, the first element corresponds to the innermost
     loop, and the last element corresponds to the outermost loop.
@@ -21,16 +21,16 @@
     shape: ArrayLikeObject<integer>
         Array dimensions.
 
-    stridesW: ArrayLikeObject<integer>
+    stridesX: ArrayLikeObject<integer>
         First input array strides.
 
-    stridesX: ArrayLikeObject<integer>
+    stridesY: ArrayLikeObject<integer>
         Second input array strides.
 
-    stridesY: ArrayLikeObject<integer>
+    stridesZ: ArrayLikeObject<integer>
         Third input array strides.
 
-    stridesZ: ArrayLikeObject<integer>
+    stridesW: ArrayLikeObject<integer>
         Output array strides.
 
     Returns
@@ -41,25 +41,30 @@
     out.sh: Array<integer>
         Ordered dimensions.
 
-    out.sw: Array<integer>
+    out.sx: Array<integer>
         First input array strides sorted in loop order.
 
-    out.sx: Array<integer>
+    out.sy: Array<integer>
         Second input array strides sorted in loop order.
 
-    out.sy: Array<integer>
+    out.sz: Array<integer>
         Third input array strides sorted in loop order.
 
-    out.sz: Array<integer>
+    out.sw: Array<integer>
         Output array strides sorted in loop order.
 
     Examples
     --------
-    > var w = {{alias:@stdlib/ndarray/array}}( [ [ 1, 2 ], [ 3, 4 ] ] );
-    > var x = {{alias:@stdlib/ndarray/array}}( [ [ 5, 6 ], [ 7, 8 ] ] );
-    > var y = {{alias:@stdlib/ndarray/array}}( [ [ 9, 10 ], [ 11, 12 ] ] );
-    > var z = {{alias:@stdlib/ndarray/array}}( [ [ 0, 0 ], [ 0, 0 ] ] );
-    > var o = {{alias}}( w.shape, w.strides, x.strides, y.strides, z.strides )
+    > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1, 2 ], [ 3, 4 ] ] );
+    > var y = {{alias:@stdlib/ndarray/array}}( [ [ 5, 6 ], [ 7, 8 ] ] );
+    > var z = {{alias:@stdlib/ndarray/array}}( [ [ 9, 10 ], [ 11, 12 ] ] );
+    > var w = {{alias:@stdlib/ndarray/array}}( [ [ 0, 0 ], [ 0, 0 ] ] );
+    > var sh = {{alias:@stdlib/ndarray/shape}}( x );
+    > var sx = {{alias:@stdlib/ndarray/strides}}( x );
+    > var sy = {{alias:@stdlib/ndarray/strides}}( y );
+    > var sz = {{alias:@stdlib/ndarray/strides}}( z );
+    > var sw = {{alias:@stdlib/ndarray/strides}}( w );
+    > var o = {{alias}}( sh, sx, sy, sz, sw )
     {...}
 
     See Also

base/ternary-loop-interchange-order/docs/types/index.d.ts

@@ -34,22 +34,22 @@ interface LoopOrderObject {
 	/**
 	* First input array strides sorted in loop order.
 	*/
-	sw: Array<number>;
+	sx: Array<number>;
 
 	/**
 	* Second input array strides sorted in loop order.
 	*/
-	sx: Array<number>;
+	sy: Array<number>;
 
 	/**
 	* Third input array strides sorted in loop order.
 	*/
-	sy: Array<number>;
+	sz: Array<number>;
 
 	/**
 	* Output array strides sorted in loop order.
 	*/
-	sz: Array<number>;
+	sw: Array<number>;
 }
 
 /**
@@ -60,10 +60,10 @@ interface LoopOrderObject {
 * -   The returned object has the following properties:
 *
 *     -   **sh**: dimensions sorted in loop order.
-*     -   **sw**: first input ndarray strides sorted in loop order.
-*     -   **sx**: second input ndarray strides sorted in loop order.
-*     -   **sy**: third input ndarray strides sorted in loop order.
-*     -   **sz**: output ndarray strides sorted in loop order.
+*     -   **sx**: first input ndarray strides sorted in loop order.
+*     -   **sy**: second input ndarray strides sorted in loop order.
+*     -   **sz**: third input ndarray strides sorted in loop order.
+*     -   **sw**: output ndarray strides sorted in loop order.
 *
 * -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
 *
@@ -74,39 +74,39 @@ interface LoopOrderObject {
 * -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
 *
 * @param shape - array dimensions
-* @param stridesW - first input array stride lengths
-* @param stridesX - second input array stride lengths
-* @param stridesY - third input array stride lengths
-* @param stridesZ - output array stride lengths
+* @param stridesX - first input array stride lengths
+* @param stridesY - second input array stride lengths
+* @param stridesZ - third input array stride lengths
+* @param stridesW - output array stride lengths
 * @returns loop interchange data
 *
 * @example
 * var sh = [ 2, 3, 4 ];
 *
-* var sw = [ 12, 4, 1 ]; // row-major
-* var sx = [ 24, 8, 1 ]; // row-major
-* var sy = [ 1, 4, 12 ]; // column-major
-* var sz = [ 1, -2, 6 ]; // column-major
+* var sx = [ 12, 4, 1 ]; // row-major
+* var sy = [ 24, 8, 1 ]; // row-major
+* var sz = [ 1, 4, 12 ]; // column-major
+* var sw = [ 1, -2, 6 ]; // column-major
 *
-* var o = ternaryLoopOrder( sh, sw, sx, sy, sz );
+* var o = ternaryLoopOrder( sh, sx, sy, sz, sw );
 * // returns {...}
 *
 * var ssh = o.sh;
 * // returns [ 2, 3, 4 ]
 *
-* var ssw = o.sw;
+* var ssx = o.sx;
 * // returns [ 12, 4, 1 ]
 *
-* var ssx = o.sx;
+* var ssy = o.sy;
 * // returns [ 24, 8, 1 ]
 *
-* var ssy = o.sy;
+* var ssz = o.sz;
 * // returns [ 1, 4, 12 ]
 *
-* var ssz = o.sz;
+* var ssw = o.sw;
 * // returns [ 1, -2, 6 ]
 */
-declare function ternaryLoopOrder( shape: ArrayLike<number>, stridesW: ArrayLike<number>, stridesX: ArrayLike<number>, stridesY: ArrayLike<number>, stridesZ: ArrayLike<number> ): LoopOrderObject;
+declare function ternaryLoopOrder( shape: ArrayLike<number>, stridesX: ArrayLike<number>, stridesY: ArrayLike<number>, stridesZ: ArrayLike<number>, stridesW: ArrayLike<number> ): LoopOrderObject;
 
 
 // EXPORTS //