From 8537fc1ea686c1457594f8ee80e4b8594b9939f9 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Fri, 6 Jun 2025 09:39:40 +0000
Subject: [PATCH 01/21] test: add 1d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.1d.js        | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js
new file mode 100644
index 000000000000..06a33636c906
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js
@@ -0,0 +1,88 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy', function test( t ) {
+	var actual;
+	var x;
+
+	x = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( 'float64', ones( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy (accessors)', function test( t ) {
+	var actual;
+	var x;
+
+	x = ndarray( 'float64', toAccessorArray( zeros( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy (complex)', function test( t ) {
+	var actual;
+	var x;
+
+	x = ndarray( 'complex128', toAccessorArray( zeros( 6, 'complex128' ) ), [ 4 ], [ 1 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( 'complex128', toAccessorArray( ones( 6, 'complex128' ) ), [ 4 ], [ 1 ], 1, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From fa882bd091812b6c04de7aff722efe0dd9971251 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Fri, 6 Jun 2025 10:55:33 +0000
Subject: [PATCH 02/21] test: add 2d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.2d.js        | 849 ++++++++++++++++++
 1 file changed, 849 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
new file mode 100644
index 000000000000..d64a86cf07c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -0,0 +1,849 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // esline-diable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ 2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ -2, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -2, bsize*2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ 2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From d56c20412930525b6fc08eac70a9d3480d4f97c3 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Fri, 6 Jun 2025 17:12:00 +0500
Subject: [PATCH 03/21] chore: fix comment

Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index d64a86cf07c5..de2deb61e766 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -313,7 +313,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	st = [ -2, -1 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // esline-diable-line max-len
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );

From 7f886c4467760a9c90efb4d22a29f0a975cecce0 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 9 Jun 2025 10:19:03 +0000
Subject: [PATCH 04/21] fix: data type

---
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: na
  - 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
---
---
 .../@stdlib/ndarray/base/every/test/test.2d.js            | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index de2deb61e766..0958374e9037 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -392,7 +392,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'float64';
+	dt = 'complex128';
 	ord = 'row-major';
 
 	bsize = blockSize( dt );
@@ -423,7 +423,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'float64';
+	dt = 'complex128';
 	ord = 'row-major';
 
 	bsize = blockSize( dt );
@@ -796,7 +796,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'float64';
+	dt = 'complex128';
 	ord = 'column-major';
 
 	bsize = blockSize( dt );
@@ -827,7 +827,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'float64';
+	dt = 'complex128';
 	ord = 'column-major';
 
 	bsize = blockSize( dt );

From 4b8479181860054ab23331d432ff2ff63c42df0e Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 9 Jun 2025 10:42:25 +0000
Subject: [PATCH 05/21] fix: coverage

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.2d.js        | 376 +++++++++++++++++-
 1 file changed, 362 insertions(+), 14 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index 0958374e9037..f2b09f54b7ff 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -77,7 +77,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 4, 1 ];
 	st = shape2strides( sh, ord );
@@ -270,8 +270,121 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	t.end();
 });
 
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
 	var actual;
+	var bsize;
 	var ord;
 	var sh;
 	var st;
@@ -281,6 +394,67 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 
 	dt = 'complex128';
 	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
@@ -307,7 +481,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ -2, -1 ];
@@ -335,7 +509,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ 4, 1 ];
@@ -363,7 +537,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ 4, -1 ];
@@ -392,7 +566,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 
 	bsize = blockSize( dt );
@@ -423,7 +597,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'row-major';
 
 	bsize = blockSize( dt );
@@ -481,7 +655,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 4, 1 ];
 	st = shape2strides( sh, ord );
@@ -674,8 +848,121 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	t.end();
 });
 
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
 	var actual;
+	var bsize;
 	var ord;
 	var sh;
 	var st;
@@ -685,6 +972,67 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 
 	dt = 'complex128';
 	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -2, bsize*2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ 2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
@@ -711,7 +1059,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ -1, -2 ];
@@ -739,7 +1087,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ 1, 4 ];
@@ -767,7 +1115,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ 4, -1 ];
@@ -796,7 +1144,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 
 	bsize = blockSize( dt );
@@ -827,7 +1175,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	var o;
 	var x;
 
-	dt = 'complex128';
+	dt = 'float64';
 	ord = 'column-major';
 
 	bsize = blockSize( dt );

From bfabd7d5a2c8fdd3e4afd52fc81f50bdfcc5d1fc Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 09:27:52 +0500
Subject: [PATCH 06/21] refactor: apply suggestions from code review

Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js
index 06a33636c906..3645e0aa8853 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.1d.js
@@ -74,12 +74,12 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray is tr
 	var actual;
 	var x;
 
-	x = ndarray( 'complex128', toAccessorArray( zeros( 6, 'complex128' ) ), [ 4 ], [ 1 ], 1, 'row-major' );
+	x = ndarray( 'complex128', zeros( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( 'complex128', toAccessorArray( ones( 6, 'complex128' ) ), [ 4 ], [ 1 ], 1, 'row-major' );
+	x = ndarray( 'complex128', ones( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );

From d28a6afa32c21689382c35cda62e50df21f9caf4 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 12:13:51 +0500
Subject: [PATCH 07/21] fix: import

Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index f2b09f54b7ff..6a6dc31dad2c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -28,7 +28,7 @@ var numel = require( '@stdlib/ndarray/base/numel' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
-var blockSize = require( '@stdlib/ndarray/base/unary-tiling-block-size' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 var every = require( './../lib' );
 
 

From 144325b9006ab8980c4079d583c97ccdbf66de0c Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sat, 14 Jun 2025 17:19:49 +0000
Subject: [PATCH 08/21] fix: apply suggestions from code review

---
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: na
  - 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
---
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index 6a6dc31dad2c..a4ec532a991e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -944,7 +944,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ 4, -1 ];
+	st = [ -1, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -1118,7 +1118,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ 4, -1 ];
+	st = [ -1, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );

From 0a9930cfd7e820f57e3a708d6de5df0afcb88255 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sat, 14 Jun 2025 18:24:39 +0000
Subject: [PATCH 09/21] feat: add 3d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.3d.js        | 1383 +++++++++++++++++
 1 file changed, 1383 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
new file mode 100644
index 000000000000..086965bfda13
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
@@ -0,0 +1,1383 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ -bsize*8, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ 2, -2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, -3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1 ];
+	st = [ 2, -bsize*4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ 2, -2, bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, -2, -3 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1 ];
+	st = [ 2, -bsize*4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -2, -2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From e7d4207be30b4825ae43cbe6cb3dc771dc456dd3 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 15 Jun 2025 09:31:25 +0000
Subject: [PATCH 10/21] feat: add 4d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.4d.js        | 1569 +++++++++++++++++
 1 file changed, 1569 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
new file mode 100644
index 000000000000..792548d5c5a8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
@@ -0,0 +1,1569 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ -2, -2, -1, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, 2, 1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, -2, -1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ -4, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2, 1 ];
+	st = [ -bsize*8, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ bsize*8, bsize*4, -2, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, bsize*4, -bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, 2, 1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, -2, -1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ -4, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2, 1 ];
+	st = [ -bsize*8, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ -bsize*4, -bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2 ];
+	st = [ -bsize*4, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, 2, 1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 4, -2, -1, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ -4, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2, 1 ];
+	st = [ -bsize*8, -4, 2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1 ];
+	st = [ bsize*4, bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2 ];
+	st = [ bsize*4, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, -2, -4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ 2, 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ 2, -2, -4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 1, 2 ];
+	st = [ 2, 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1 ];
+	st = [ 2, -bsize*4, -bsize*4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1 ];
+	st = [ 1, 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1 ];
+	st = [ 2, 4, -4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*4 ];
+	st = [ 2, 4, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2 ];
+	st = [ -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1 ];
+	st = [ 1, -2, -4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, 1, bsize*2 ];
+	st = [ 2, 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 1 ];
+	st = [ 2, 2, -4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 1, 2 ];
+	st = [ 2, 2, -bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 020a50b6a56c02b441c7a894010fba5245d98923 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 15 Jun 2025 10:54:10 +0000
Subject: [PATCH 11/21] feat: add 5d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.5d.js        | 1755 +++++++++++++++++
 1 file changed, 1755 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
new file mode 100644
index 000000000000..4fc9cb6d6df4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
@@ -0,0 +1,1755 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 1, 2, 2 ];
+	st = [ -8, -4, -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, 2, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, -2, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ 8, -8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, -4, 4, -4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1 ];
+	st = [ bsize*8, bsize*8, -bsize*4, -2, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, 2, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ 8, -8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ -bsize*8, -4, 4, -4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, 2, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 8, 4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ 8, -8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ -bsize*8, -4, 4, -4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2, 2 ];
+	st = [ -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, -2, -2, -4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2 ];
+	st = [ -2, 4, -bsize*8, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ -2, 4, -4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ -2, 4, -4, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ -2, 4, -4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1 ];
+	st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ -2, 4, -4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ -2, -4, -4, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, 4, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, 2, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2 ];
+	st = [ 1, -2, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2 ];
+	st = [ -2, bsize*4, -bsize*4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1 ];
+	st = [ -2, 4, -bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2 ];
+	st = [ -2, 4, -4, bsize*8, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2 ];
+	st = [ -2, -4, -4, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, 4, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 1e9f123500c91a67115ba683e7830a3016de901c Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 15 Jun 2025 17:39:39 +0000
Subject: [PATCH 12/21] feat: add 6d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.6d.js        | 1941 +++++++++++++++++
 1 file changed, 1941 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
new file mode 100644
index 000000000000..0d4985c9e072
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
@@ -0,0 +1,1941 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, -16, 8, -4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 8, -8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ bsize*8, -4, -4, 4, 4, -2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, bsize*8, -bsize*8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, -16, 8, -4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 8, -8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ -bsize*8, -4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 8, -4, -4, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 8, -8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ -bsize*8, -4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ bsize*8, bsize*8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ bsize*8, -bsize*8, -bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ bsize*8, -bsize*8, -bsize*4, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, -1, 1, -2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 1 ];
+	st = [ 2, 4, 4, -4, 8, -bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ 2, 4, 4, -8, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 1 ];
+	st = [ 2, 4, 4, -4, 8, -bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ 2, 4, 4, -8, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2 ];
+	st = [ 2, 4, bsize*8, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, -bsize*8, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, -4, bsize*8, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 1 ];
+	st = [ 2, 4, 4, -4, 8, -bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2 ];
+	st = [ 2, 4, 4, -8, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From ff52fc322379ac737f2f3e57222a6732bdbff2ef Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 15 Jun 2025 18:36:09 +0000
Subject: [PATCH 13/21] feat: add 7d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.7d.js        | 2127 +++++++++++++++++
 1 file changed, 2127 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
new file mode 100644
index 000000000000..091546da3607
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
@@ -0,0 +1,2127 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, -16, 8, -4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 16, -16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*16, -8, 8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -8, -8, -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -16, 16, -16, -8, -4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 16, -16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ bsize*16, -8, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ bsize*16, bsize*16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*16, -bsize*16, -bsize*8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ];
+	st = [ bsize*16, -bsize*16, -bsize*16, -bsize*8, bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -8, -8, -4, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -16, 16, -16, 8, -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 16, -16, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*16, -8, 8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, -8, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 1, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ bsize*16, -bsize*16, -bsize*8, -bsize*8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, 1, bsize*2, 2 ];
+	st = [ bsize*16, -bsize*16, bsize*16, bsize*8, -bsize*8, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*4, bsize*4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 2, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, -1, 2, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 2, 1, 2, 1 ];
+	st = [ 2, -4, bsize*8, -bsize*8, bsize*16, -bsize*16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 1, 2 ];
+	st = [ 2, -4, -4, 4, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, -4, -4, 8, 8, 16, 16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, -2, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, -bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, 4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, 4, -bsize*8, bsize*8, -bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ];
+	st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, -4, -4, 8, 8, 16, 16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2, 1, 2, 1, 2 ];
+	st = [ -1, -2, -2, -4, -4, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 2, 4, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, -2, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 1, 2, 2 ];
+	st = [ 2, -4, -4, 4, bsize*8, bsize*8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, bsize*2 ];
+	st = [ 2, -4, -4, 8, 8, 16, 16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 756302d5655bdbe4c97c90d95110c7bffdbecacc Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Sun, 15 Jun 2025 19:37:52 +0000
Subject: [PATCH 14/21] feat: add 8d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.8d.js        | 2340 +++++++++++++++++
 1 file changed, 2340 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
new file mode 100644
index 000000000000..03642939dae9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
@@ -0,0 +1,2340 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, -16, 8, -4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ];
+	st = [ 32, -16, 8, -8, -8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*32, -16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ];
+	st = [ -bsize*32, -bsize*32, -bsize*16, -bsize*16, -bsize*16, 8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ -bsize*16, -bsize*16, -bsize*8, bsize*8, bsize*8, bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ];
+	st = [
+		-bsize*16,
+		-bsize*16,
+		-bsize*8,
+		bsize*8,
+		bsize*8,
+		bsize*4,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, -16, 16, -16, -8, -4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ];
+	st = [ 32, 16, 8, -8, -8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ];
+	st = [ bsize*32, bsize*32, 16, 8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ];
+	st = [ bsize*32, -bsize*32, -bsize*32, -16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ];
+	st = [ bsize*32, -bsize*32, bsize*16, -bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ];
+	st = [ bsize*32, -bsize*32, -bsize*16, -bsize*16, bsize*16, 8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ -bsize*16, -bsize*16, bsize*8, -bsize*8, -bsize*8, bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ];
+	st = [
+		-bsize*16,
+		-bsize*16,
+		bsize*8,
+		-bsize*8,
+		-bsize*8,
+		bsize*4,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, -16, 16, -16, 8, -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 2 ];
+	st = [ 32, 16, 8, -8, -8, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2, 2, 1, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, 16, -8, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, bsize*2, 2, 2, 1, 2 ];
+	st = [ -bsize*32, bsize*32, -bsize*32, -16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, bsize*2, 2, 1, 2 ];
+	st = [ -bsize*32, -bsize*32, -bsize*16, -bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, bsize*2, 2, 2 ];
+	st = [ -bsize*32, -bsize*32, bsize*16, bsize*16, -bsize*16, 8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, bsize*2, 2 ];
+	st = [ -bsize*16, -bsize*16, bsize*8, bsize*8, -bsize*8, bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 1, bsize*2 ];
+	st = [
+		-bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*4,
+		-bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, -1, 2, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, bsize*8, -bsize*8, bsize*8, bsize*8, -bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, 16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ];
+	st = [ 2, bsize*4, bsize*4, -bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, -bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, 4, 8, -bsize*16, bsize*16, -bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, 16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2, 1, 1, 2, 1, 2 ];
+	st = [ 2, -bsize*4, -bsize*4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 1, 1, 2, 1, 2 ];
+	st = [ 2, -4, -8, bsize*16, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 1, 2, 1, 2 ];
+	st = [ 2, -4, -4, 8, bsize*16, bsize*16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 1, 1, 2 ];
+	st = [ 2, -4, -4, 8, 16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 1, 2 ];
+	st = [ 2, -4, -4, 8, 8, 16, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, -4, -4, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 753bc916fdebeecd128b3b3d8709ba5bc0cee96d Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 05:32:16 +0000
Subject: [PATCH 15/21] feat: add 9d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.9d.js        | 2649 +++++++++++++++++
 1 file changed, 2649 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
new file mode 100644
index 000000000000..a55b91207f4e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
@@ -0,0 +1,2649 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, -16, 8, -4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ 32, -16, 8, -8, -8, 4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ -bsize*32, -16, 8, -8, -8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ -bsize*64, -bsize*32, 16, -8, -8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ -bsize*64, -bsize*64, bsize*32, -bsize*16, -8, 4, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ -bsize*64, -bsize*64, -bsize*32, -bsize*32, -bsize*16, 8, -4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		-bsize*64,
+		-bsize*64,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		8,
+		-4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		-bsize*64,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		-4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ 32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*32, -16, -8, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*32, -16, 8, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, 16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*16, 8, -4, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ bsize*64, -bsize*64, -bsize*32, bsize*32, bsize*16, -8, 4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		-bsize*64,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		-4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2 ];
+	st = [
+		-bsize*32,
+		-bsize*32,
+		-bsize*16,
+		bsize*16,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2, 1, 1, 1, 1, 1 ];
+	st = [ -1, -2, -4, -4, -8, -8, -8, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2, 1, 1, 1, 1, 1 ];
+	st = [ -1, -2, -4, -4, -8, -8, -8, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 1, 2, 1, 1, 1, 1, 1 ];
+	st = [ -1, -2, -4, -4, -8, -8, -8, -8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 1, 1, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16,
+		bsize*16
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 1, 1, 2 ];
+	st = [ 2, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32, bsize*32 ]; // eslint-disable-line max-len
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 8, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 786cb723d75a44c2bd34b0cc8979fed2bf186aa9 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 05:53:55 +0000
Subject: [PATCH 16/21] feat: add 10d tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.10d.js       | 2949 +++++++++++++++++
 1 file changed, 2949 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
new file mode 100644
index 000000000000..7ba376837527
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
@@ -0,0 +1,2949 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*16,
+		-8,
+		4,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*16,
+		-8,
+		4,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -8, -8, -8, -8, -8, -8, -4, -2, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ 32, 16, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, 32, 16, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*32, 16, -8, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [ bsize*64, bsize*64, bsize*32, -16, 8, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*16, 8, 4, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ bsize*32, bsize*32, bsize*32, -bsize*32, bsize*16, 8, -4, 4, 4, 2 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*16,
+		-8,
+		4,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 1, 2, bsize*2, 2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*32,
+		bsize*32,
+		-bsize*16,
+		8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [
+		bsize*64,
+		bsize*64,
+		bsize*32,
+		-bsize*32,
+		bsize*16,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [
+		bsize*32,
+		bsize*32,
+		bsize*16,
+		-bsize*16,
+		bsize*8,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*4,
+		2
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ -1, -1, -1, -1, -1, -1, -1, -2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		-bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		-bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2, 1 ];
+	st = [ -1, -1, -1, -1, -1, -1, -2, -4, -4, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		bsize*4,
+		bsize*8,
+		-bsize*8,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		-bsize*32,
+		bsize*32,
+		bsize*32
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 2, 1, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		bsize*8,
+		bsize*16,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 2, bsize*2, 2, 1, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, bsize*2, 2, 1, 2, 1, 1, 2 ];
+	st = [
+		2,
+		4,
+		4,
+		8,
+		bsize*16,
+		bsize*32,
+		bsize*32,
+		bsize*64,
+		bsize*64,
+		bsize*64
+	];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 2, bsize*2, 2, 1, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 1, 1, 2, bsize*2, 2, 1, 1, 2 ];
+	st = [ 2, 4, 4, 4, 4, 8, bsize*16, bsize*32, bsize*32, bsize*32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 1, 2, bsize*2, 2, 1, 2 ];
+	st = [ 2, 4, 4, 8, 8, 8, 16, bsize*32, bsize*64, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 2, bsize*2, 2, 1 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 32, bsize*64, bsize*128 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 2, bsize*2, 2 ];
+	st = [ 2, 4, 4, 8, 8, 16, 16, 16, 32, bsize*64 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var actual;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, 2, 1, 2, 1, 1, 1, 2, bsize*2 ];
+	st = [ 2, 4, 4, 8, 8, 16, -16, 16, 16, 32 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From af74100129380e2d0a47490055fdf1e708e904f4 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 06:14:54 +0000
Subject: [PATCH 17/21] feat: add nd tests

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.nd.js        | 656 ++++++++++++++++++
 1 file changed, 656 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js
new file mode 100644
index 000000000000..1ff80aedd70c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js
@@ -0,0 +1,656 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var every = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof every, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 16, 16, 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, contiguous, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var actual;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var x;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
+	st = [ 1, 1, 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	o = strides2offset( sh, st );
+
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, false, 'returns expected value' );
+
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From 6a87744c13ffd0f5b2fb22a83737ff730f15a308 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 06:58:46 +0000
Subject: [PATCH 18/21] feat: add empty array case

---
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: na
  - 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
---
---
 .../@stdlib/ndarray/base/every/test/test.js        | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.js
index e03546fc646a..bc338fbc7578 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.js
@@ -21,6 +21,8 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
 var every = require( './../lib' );
 
 
@@ -31,3 +33,15 @@ tape( 'main export is a function', function test( t ) {
 	t.strictEqual( typeof every, 'function', 'main export is a function' );
 	t.end();
 });
+
+tape( 'the function returns `true` if the input is an empty ndarray', function test( t ) {
+	var actual;
+	var x;
+
+	x = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+	actual = every( [ x ] );
+	t.strictEqual( actual, true, 'returns expected value' );
+
+	t.end();
+});

From b61bb968d95d71b40704696c7c38549d49a4becf Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 23:07:01 +0500
Subject: [PATCH 19/21] fix: order

Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
index 086965bfda13..8aa83fe1a65b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
@@ -1038,7 +1038,7 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
 	st = [ 1, 2, 3 ];
 	o = strides2offset( sh, st );

From 1dd55b5c3acda77cde8a6d900dae07655a5f480a Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 23:53:24 +0500
Subject: [PATCH 20/21] fix: apply suggestions from code review

Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
 lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js  | 2 +-
 lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js  | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
index 7ba376837527..7ec2f5b9301b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
@@ -2082,7 +2082,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
index 792548d5c5a8..044603569e0e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
@@ -1162,7 +1162,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
 	st = [ 1, 2, 4, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
index 4fc9cb6d6df4..87b469ddb350 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
@@ -1286,7 +1286,7 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
 	st = [ 1, 2, 2, 4, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
index 0d4985c9e072..68450fda8b60 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
@@ -1410,7 +1410,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 2, 4, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
index 091546da3607..5063858804e8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
@@ -1534,7 +1534,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 1, 2, 4, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
index 03642939dae9..b697a750e692 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
@@ -1685,7 +1685,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
index a55b91207f4e..61a084038cd8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
@@ -1892,7 +1892,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
 	o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js
index 1ff80aedd70c..11c4e16080e5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.nd.js
@@ -525,7 +525,7 @@ tape( 'the function tests whether every element in a n-dimensional ndarray is tr
 	var x;
 
 	dt = 'complex128';
-	ord = 'row-major';
+	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
 	st = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
 	o = strides2offset( sh, st );

From 8ee084f2ca6cf0b0dd1d68f821729642959e5655 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 17 Jun 2025 21:08:18 +0000
Subject: [PATCH 21/21] fix: noncontiguous strides

---
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: na
  - 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
---
---
 .../ndarray/base/every/test/test.10d.js       | 22 +++---
 .../ndarray/base/every/test/test.2d.js        | 24 +++----
 .../ndarray/base/every/test/test.3d.js        | 68 +++++++++---------
 .../ndarray/base/every/test/test.4d.js        | 24 +++----
 .../ndarray/base/every/test/test.5d.js        | 72 +++++++++----------
 .../ndarray/base/every/test/test.6d.js        | 48 ++++++-------
 .../ndarray/base/every/test/test.7d.js        | 24 +++----
 .../ndarray/base/every/test/test.8d.js        | 24 +++----
 .../ndarray/base/every/test/test.9d.js        | 24 +++----
 9 files changed, 165 insertions(+), 165 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
index 7ec2f5b9301b..6981a35d6463 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.10d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 16, -8, -4, -2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 16, -8, -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -630,7 +630,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1096,7 +1096,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1124,7 +1124,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	st = [ 16, 16, 16, 16, -16, 16, -8, -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1618,7 +1618,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1646,7 +1646,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	st = [ 2, 2, 2, 2, 2, 2, -2, -4, 8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -2084,7 +2084,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -2112,7 +2112,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	st = [ 2, 2, -2, 2, -2, 2, 2, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -2550,7 +2550,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -2578,7 +2578,7 @@ tape( 'the function tests whether every element in a 10-dimensional ndarray is t
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	st = [ 2, 2, -2, 2, -2, 2, 2, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
index a4ec532a991e..710fd945d44c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.2d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, 1 ];
+	st = [ 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, -1 ];
+	st = [ 4, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -338,7 +338,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, 1 ];
+	st = [ 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -366,7 +366,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, -1 ];
+	st = [ 4, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -512,7 +512,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, 1 ];
+	st = [ 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -540,7 +540,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
-	st = [ 4, -1 ];
+	st = [ 4, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -742,7 +742,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ 1, 4 ];
+	st = [ 2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -770,7 +770,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ -1, 4 ];
+	st = [ -2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -916,7 +916,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ 1, 4 ];
+	st = [ 2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -944,7 +944,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ -1, 4 ];
+	st = [ -2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -1090,7 +1090,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ 1, 4 ];
+	st = [ 2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -1118,7 +1118,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
-	st = [ -1, 4 ];
+	st = [ -2, 4 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
index 8aa83fe1a65b..61d59e4f5d40 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.3d.js
@@ -164,15 +164,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 3, 2, 1 ];
+	st = [ 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -192,15 +192,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
-	st = [ -3, -2, 1 ];
+	st = [ -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -369,15 +369,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 3, 2, 1 ];
+	st = [ 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -397,15 +397,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
-	st = [ -3, -2, -1 ];
+	st = [ -4, -4, -2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -574,15 +574,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 3, 2, 1 ];
+	st = [ 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -605,12 +605,12 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	st = [ -3, -2, 1 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -835,15 +835,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 1, 2, 4 ];
+	st = [ 2, 4, 4 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -863,15 +863,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 1, -2, -4 ];
+	st = [ 2, -4, -4 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1040,15 +1040,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 1, 2, 3 ];
+	st = [ 2, 4, 4 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1068,15 +1068,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
-	st = [ -1, -2, -3 ];
+	st = [ -2, -4, -4 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 6, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1245,15 +1245,15 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
-	st = [ 1, 2, 3 ];
+	st = [ 2, 4, 4 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1276,12 +1276,12 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray is tr
 	st = [ 1, -2, -3 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 6, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
index 044603569e0e..69db13f0165e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.4d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, 2, 1, 1 ];
+	st = [ 4, 4, 2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, -2, -1, 1 ];
+	st = [ 4, -4, -2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -400,7 +400,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, 2, 1, 1 ];
+	st = [ 4, 4, 2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -428,7 +428,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, -2, -1, 1 ];
+	st = [ 4, -4, -2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -636,7 +636,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, 2, 1, 1 ];
+	st = [ 4, 4, 2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -664,7 +664,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 4, -2, -1, 1 ];
+	st = [ 4, -4, -2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -928,7 +928,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -956,7 +956,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, -2, -4, 8 ];
+	st = [ 2, -4, -4, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -1164,7 +1164,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -1192,7 +1192,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, 2, -4, -8 ];
+	st = [ 2, 4, -4, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
@@ -1400,7 +1400,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
@@ -1428,7 +1428,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1 ];
-	st = [ 1, -2, -4, 8 ];
+	st = [ 2, -4, -4, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 8, dt ) ), sh, st, o, ord );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
index 87b469ddb350..06082b0e4d6d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.5d.js
@@ -164,15 +164,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, 2, 2, 1 ];
+	st = [ 8, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -192,15 +192,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, -2, -2, 1 ];
+	st = [ 8, 8, -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -431,15 +431,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, 2, 2, 1 ];
+	st = [ 8, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -459,15 +459,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, -2, -2, -1 ];
+	st = [ 8, 8, -4, -4, -2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -698,15 +698,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, 2, 2, 1 ];
+	st = [ 8, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -726,15 +726,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 8, 4, -2, -2, -1 ];
+	st = [ 8, 8, -4, -4, -2 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1021,15 +1021,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, 2, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1049,15 +1049,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, -2, -2, -4, 8 ];
+	st = [ 2, -4, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1288,15 +1288,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, 2, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1316,15 +1316,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, 2, -2, -4, -8 ];
+	st = [ 2, 4, -4, -8, -8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1555,15 +1555,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, 2, 2, 4, 8 ];
+	st = [ 2, 4, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1583,15 +1583,15 @@ tape( 'the function tests whether every element in a 5-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 2, 1, 2, 1, 2 ];
-	st = [ 1, -2, -2, -4, -8 ];
+	st = [ 2, -4, -4, -8, -8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( numel( sh )*2, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( numel( sh )*2, dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
index 68450fda8b60..e1acb0437f2a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.6d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, -16, 8, -4, 4, 1 ];
+	st = [ 16, -16, 8, -4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -462,7 +462,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -490,7 +490,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, -16, 8, -4, 4, 1 ];
+	st = [ 16, -16, 8, -4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -760,7 +760,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -788,7 +788,7 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 8, -4, -4, -1 ];
+	st = [ 16, 16, 8, -4, -4, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1114,15 +1114,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 2, 4, 8 ];
+	st = [ 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1142,15 +1142,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, -1, 1, -2, 4, 8 ];
+	st = [ 2, -2, 2, -4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1412,15 +1412,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 2, 4, 8 ];
+	st = [ 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1440,15 +1440,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, -2, -4, -8 ];
+	st = [ 2, 2, 2, -4, -8, -8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, zeros( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, ones( 12, dt ), sh, st, o, ord );
+	x = ndarray( dt, ones( 16, dt ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1710,15 +1710,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 2, 4, 8 ];
+	st = [ 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
@@ -1738,15 +1738,15 @@ tape( 'the function tests whether every element in a 6-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, -2, -4, -8 ];
+	st = [ 2, 2, 2, -4, -8, -8 ];
 	o = strides2offset( sh, st );
 
-	x = ndarray( dt, toAccessorArray( zeros( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, false, 'returns expected value' );
 
-	x = ndarray( dt, toAccessorArray( ones( 12, dt ) ), sh, st, o, ord );
+	x = ndarray( dt, toAccessorArray( ones( 16, dt ) ), sh, st, o, ord );
 
 	actual = every( [ x ] );
 	t.strictEqual( actual, true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
index 5063858804e8..0829dc27668e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.7d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, -16, 8, -4, 4, 1 ];
+	st = [ 16, 16, -16, 8, -4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -493,7 +493,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -521,7 +521,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ -16, 16, -16, -8, -4, 2, 1 ];
+	st = [ -16, 16, -16, -8, -4, 2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -822,7 +822,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -850,7 +850,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ -16, 16, -16, 8, -4, -2, -1 ];
+	st = [ -16, 16, -16, 8, -4, -2, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1207,7 +1207,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 2, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1235,7 +1235,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, -1, 2, -4, 8, -8 ];
+	st = [ 2, 2, -2, 2, -4, 8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1536,7 +1536,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 2, 4, 8 ];
+	st = [ 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1564,7 +1564,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, -2, -4, -8, 8 ];
+	st = [ 2, 2, 2, -2, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1865,7 +1865,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 2, 4, 8 ];
+	st = [ 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1893,7 +1893,7 @@ tape( 'the function tests whether every element in a 7-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, -2, -4, -8 ];
+	st = [ 2, 2, 2, 2, -4, -8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
index b697a750e692..e5d88ab7e712 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.8d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, -16, 8, -4, 4, 1 ];
+	st = [ 16, 16, 16, -16, 8, -4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -533,7 +533,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -561,7 +561,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, -16, 16, -16, -8, -4, 2, 1 ];
+	st = [ 16, -16, 16, -16, -8, -4, 2, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -902,7 +902,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 8, 4, 4, 1 ];
+	st = [ 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -930,7 +930,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, -16, 16, -16, 8, -4, -2, -1 ];
+	st = [ 16, -16, 16, -16, 8, -4, -2, -2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1327,7 +1327,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1355,7 +1355,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, -1, 2, -4, 8, -8 ];
+	st = [ 2, 2, 2, -2, 2, -4, 8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1687,7 +1687,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1715,7 +1715,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ -1, 1, -1, 1, 1, -4, -8, 8 ];
+	st = [ -2, 2, -2, 2, 2, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -2047,7 +2047,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -2075,7 +2075,7 @@ tape( 'the function tests whether every element in a 8-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, -4, -8, 8 ];
+	st = [ 2, 2, 2, 2, 2, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
index 61a084038cd8..91e5d5e866f0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every/test/test.9d.js
@@ -164,7 +164,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -192,7 +192,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, -16, 8, -4, 2, 1 ];
+	st = [ 16, 16, 16, 16, -16, 8, -4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -585,7 +585,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -613,7 +613,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	st = [ 16, 16, 16, -16, 16, -8, -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1006,7 +1006,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, 16, 16, 8, 4, 2, 1 ];
+	st = [ 16, 16, 16, 16, 16, 8, 4, 4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1034,7 +1034,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'row-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 16, 16, 16, -16, 16, -8, -4, -2, 1 ];
+	st = [ 16, 16, 16, -16, 16, -8, -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -1483,7 +1483,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1511,7 +1511,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	st = [ 2, 2, 2, 2, 2, -2, -4, 8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1894,7 +1894,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -1922,7 +1922,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, -1, 1, -1, 1, 1, -4, -8, 8 ];
+	st = [ 2, -2, 2, -2, 2, 1, -4, -8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, zeros( 16, dt ), sh, st, o, ord );
@@ -2305,7 +2305,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, 1, 4, 8, 8 ];
+	st = [ 2, 2, 2, 2, 2, 2, 4, 8, 8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );
@@ -2333,7 +2333,7 @@ tape( 'the function tests whether every element in a 9-dimensional ndarray is tr
 	dt = 'float64';
 	ord = 'column-major';
 	sh = [ 1, 1, 1, 1, 1, 2, 2, 1, 2 ];
-	st = [ 1, 1, 1, 1, 1, -1, -4, 8, -8 ];
+	st = [ 2, 2, 2, 2, 2, -2, -4, 8, -8 ];
 	o = strides2offset( sh, st );
 
 	x = ndarray( dt, toAccessorArray( zeros( 16, dt ) ), sh, st, o, ord );