fix: ensure separate array instance for each memory layout

---
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: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - 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: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/binary-loop-interchange-order/lib/main.js

@@ -23,7 +23,6 @@
 var zeroTo = require( '@stdlib/array/base/zero-to' );
 var copy = require( '@stdlib/array/base/copy-indexed' );
 var take = require( '@stdlib/array/base/take-indexed' );
-var filled = require( '@stdlib/array/base/filled' );
 var strides2order = require( '@stdlib/ndarray/base/strides2order' );
 var sort2ins = require( './sort2ins.js' );
 
@@ -97,7 +96,7 @@ function loopOrder( sh, sx, sy, sz ) {
 	oz = strides2order( sz );
 
 	// Determine which array should be used to generate the loop order:
-	tmp = filled( [], 4 );
+	tmp = [ [], [], [], [] ];
 	tmp[ ox ].push( sx );
 	tmp[ oy ].push( sy );
 	tmp[ oz ].push( sz );
@@ -132,9 +131,9 @@ function loopOrder( sh, sx, sy, sz ) {
 
 	// Permute the shape and array strides based on the sorted strides:
 	sh = take( sh, idx );
-	sx = ( sx === arr ) ? arr : take( sx, idx );
-	sy = ( sy === arr ) ? arr : take( sy, idx );
-	sz = ( sz === arr ) ? arr : take( sz, idx );
+	sx = take( sx, idx );
+	sy = take( sy, idx );
+	sz = take( sz, idx );
 
 	return {
 		'sh': sh,

lib/node_modules/@stdlib/ndarray/base/binary-loop-interchange-order/lib/sort2ins.js

@@ -27,7 +27,7 @@
 *
 * -   The first array is sorted in increasing order according to absolute value.
 * -   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-* -   The algorithm is efficient for small arrays (typically `N <= 20``) and is particularly efficient for sorting arrays which are already substantially sorted.
+* -   The algorithm is efficient for small arrays (typically `N <= 20`) and is particularly efficient for sorting arrays which are already substantially sorted.
 * -   The algorithm is **stable**, meaning that the algorithm does **not** change the order of array elements which are equal or equivalent.
 * -   The input arrays are sorted in-place (i.e., the input arrays are mutated).
 *

lib/node_modules/@stdlib/ndarray/base/binary-loop-interchange-order/test/test.js

@@ -132,6 +132,72 @@ tape( 'the function returns loop interchange data (mixed order)', function test(
 	t.end();
 });
 
+tape( 'the function returns loop interchange data (mostly disorganized)', function test( t ) {
+	var sh;
+	var sx;
+	var sy;
+	var sz;
+	var o;
+
+	sh = [ 4, 2, 2 ];
+	sx = [ -2, 4, 1 ]; // disorganized
+	sy = [ -4, 2, 1 ]; // row-major
+	sz = [ -8, -2, 4 ]; // disorganized
+
+	o = loopOrder( sh, sx, sy, sz );
+
+	t.notEqual( o.sh, sh, 'returns new array' );
+	t.strictEqual( isArray( o.sh ), true, 'returns expected value' );
+	t.deepEqual( o.sh, [ 2, 2, 4 ], 'returns expected value' );
+
+	t.notEqual( o.sx, sx, 'returns new array' );
+	t.strictEqual( isArray( o.sx ), true, 'returns expected value' );
+	t.deepEqual( o.sx, [ 1, 4, -2 ], 'returns expected value' );
+
+	t.notEqual( o.sy, sy, 'returns new array' );
+	t.strictEqual( isArray( o.sy ), true, 'returns expected value' );
+	t.deepEqual( o.sy, [ 1, 2, -4 ], 'returns expected value' );
+
+	t.notEqual( o.sz, sz, 'returns new array' );
+	t.strictEqual( isArray( o.sz ), true, 'returns expected value' );
+	t.deepEqual( o.sz, [ 4, -2, -8 ], 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns loop interchange data (all disorganized)', function test( t ) {
+	var sh;
+	var sx;
+	var sy;
+	var sz;
+	var o;
+
+	sh = [ 4, 2, 2 ];
+	sx = [ -2, 4, 1 ]; // disorganized
+	sy = [ 1, -4, 2 ]; // disorganized
+	sz = [ -8, -2, 4 ]; // disorganized
+
+	o = loopOrder( sh, sx, sy, sz );
+
+	t.notEqual( o.sh, sh, 'returns new array' );
+	t.strictEqual( isArray( o.sh ), true, 'returns expected value' );
+	t.deepEqual( o.sh, [ 2, 4, 2 ], 'returns expected value' );
+
+	t.notEqual( o.sx, sx, 'returns new array' );
+	t.strictEqual( isArray( o.sx ), true, 'returns expected value' );
+	t.deepEqual( o.sx, [ 1, -2, 4 ], 'returns expected value' );
+
+	t.notEqual( o.sy, sy, 'returns new array' );
+	t.strictEqual( isArray( o.sy ), true, 'returns expected value' );
+	t.deepEqual( o.sy, [ 2, 1, -4 ], 'returns expected value' );
+
+	t.notEqual( o.sz, sz, 'returns new array' );
+	t.strictEqual( isArray( o.sz ), true, 'returns expected value' );
+	t.deepEqual( o.sz, [ 4, -8, -2 ], 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'if provided empty arrays, the function returns empty arrays', function test( t ) {
 	var o = loopOrder( [], [], [], [] );
 	t.deepEqual( o.sh, [], 'returns expected value' );