From 7449988a8e92394fc9c4cec5cd7581b608811e0a Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 9 Jun 2025 11:35:02 +0000
Subject: [PATCH 01/19] feat: add 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-by/test/test.1d.js | 102 ++
.../ndarray/base/every-by/test/test.2d.js | 1359 +++++++++++++++++
2 files changed, 1461 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
new file mode 100644
index 000000000000..629045f1469e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
@@ -0,0 +1,102 @@
+/**
+* @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 ones = require( '@stdlib/array/ones' );
+var zeros = require( '@stdlib/array/zeros' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, '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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( 'float64', ones( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( 'complex128', toAccessorArray( ones( 6, 'complex128' ) ), [ 4 ], [ 1 ], 1, 'row-major' );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
new file mode 100644
index 000000000000..fe8998a5f297
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -0,0 +1,1359 @@
+/**
+* @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 real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, '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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = [ bsize*2, 2 ];
+ st = [ -4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 );
+
+ x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+ actual = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 ); // eslint-disable-line max-len
+
+ actual = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = [ bsize*2, 2 ];
+ st = [ -2, bsize*2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ }
+});
+
+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 );
+
+ x = ndarray( dt, toAccessorArray( zeros( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+
+ actual = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = 'float64';
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+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 = everyBy( [ x ], clbk );
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
From 1ddae2f033e25eceb048f9bcaa2fea881d1d6289 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 09:29:56 +0500
Subject: [PATCH 02/19] refactor: apply suggestions from code review
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
.../@stdlib/ndarray/base/every-by/test/test.1d.js | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
index 629045f1469e..9c437e7f0302 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
@@ -84,12 +84,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 = everyBy( [ x ], clbk );
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 = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
From 9c7842521ded5d089c12d0954f8c7a82081ac2ce Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 06:13:53 +0000
Subject: [PATCH 03/19] fix: description
---
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-by/test/test.1d.js | 6 +-
.../ndarray/base/every-by/test/test.2d.js | 80 +++++++++----------
2 files changed, 43 insertions(+), 43 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
index 629045f1469e..aa77557ca185 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
@@ -38,7 +38,7 @@ tape( 'main export is a function', function test( t ) {
t.end();
});
-tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy', function test( t ) {
+tape( 'the function tests whether every element in a 1-dimensional ndarray passes a test implemented by a predicate function', function test( t ) {
var actual;
var x;
@@ -59,7 +59,7 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy (accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 1-dimensional ndarray passes a test implemented by a predicate function (accessors)', function test( t ) {
var actual;
var x;
@@ -80,7 +80,7 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 1-dimensional ndarray is truthy (complex)', function test( t ) {
+tape( 'the function tests whether every element in a 1-dimensional ndarray passes a test implemented by a predicate function (complex)', function test( t ) {
var actual;
var x;
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index fe8998a5f297..f2c992630f46 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -42,7 +42,7 @@ tape( 'main export is a function', function test( t ) {
t.end();
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, singleton dimensions)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions)', function test( t ) {
var actual;
var ord;
var sh;
@@ -74,7 +74,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, singleton dimensions, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -106,7 +106,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous)', function test( t ) {
var actual;
var ord;
var sh;
@@ -138,7 +138,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -170,7 +170,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, same sign strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -202,7 +202,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -234,7 +234,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -269,7 +269,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -304,7 +304,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -336,7 +336,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -368,7 +368,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -400,7 +400,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -432,7 +432,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, complex)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -467,7 +467,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, complex)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -502,7 +502,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -534,7 +534,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, contiguous, negative strides, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -566,7 +566,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -598,7 +598,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -630,7 +630,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -665,7 +665,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -700,7 +700,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, singleton dimensions)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions)', function test( t ) {
var actual;
var ord;
var sh;
@@ -732,7 +732,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, singleton dimensions, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -764,7 +764,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous)', function test( t ) {
var actual;
var ord;
var sh;
@@ -796,7 +796,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -828,7 +828,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, same sign strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -860,7 +860,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides)', function test( t ) {
var actual;
var ord;
var sh;
@@ -892,7 +892,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -927,7 +927,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -962,7 +962,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -994,7 +994,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1026,7 +1026,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1058,7 +1058,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, complex)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1090,7 +1090,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, complex)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -1125,7 +1125,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, complex)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, complex)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -1160,7 +1160,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1192,7 +1192,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, contiguous, negative strides, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1224,7 +1224,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1256,7 +1256,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-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 ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
var actual;
var ord;
var sh;
@@ -1288,7 +1288,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
var ord;
@@ -1323,7 +1323,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray is tr
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray is truthy (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
var ord;
From f1ca71aed8fc8cb97e236d16f07c5d71b62bbc5f Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 12:14:39 +0500
Subject: [PATCH 04/19] fix: import
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index f2c992630f46..044e8fa150a3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -30,7 +30,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 everyBy = require( './../lib' );
From 175b530dc9bc3ccac496bd4f96b9ace72c5c8049 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 10 Jun 2025 10:28:24 +0000
Subject: [PATCH 05/19] fix: cleanup
---
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-by/test/test.0d.js | 24 -
.../ndarray/base/every-by/test/test.1d.js | 32 +-
.../ndarray/base/every-by/test/test.2d.js | 556 ++++--------------
3 files changed, 108 insertions(+), 504 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.0d.js
index e89956f46ec8..4e2ff5c6aca5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.0d.js
@@ -21,13 +21,10 @@
// MODULES //
var tape = require( 'tape' );
-var Float64Array = require( '@stdlib/array/float64' );
-var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
var Complex128 = require( '@stdlib/complex/float64/ctor' );
var real = require( '@stdlib/complex/float64/real' );
var imag = require( '@stdlib/complex/float64/imag' );
var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-var ndarray = require( '@stdlib/ndarray/ctor' );
var everyBy = require( './../lib' );
@@ -68,27 +65,6 @@ tape( 'the function tests whether every element in a 0-dimensional ndarray passe
var actual;
var x;
- x = ndarray( 'generic', toAccessorArray( new Float64Array( [ 0.0 ] ) ), [], [ 0 ], 0, 'row-major' );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( 'generic', toAccessorArray( new Float64Array( [ 1.0 ] ) ), [], [ 0 ], 0, 'row-major' );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return v !== 0.0;
- }
-});
-
-tape( 'the function tests whether every element in a 0-dimensional ndarray passes a test implemented by a predicate function (complex)', function test( t ) {
- var actual;
- var x;
-
x = scalar2ndarray( new Complex128( 0.0, 0.0 ), {
'dtype': 'complex128'
});
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
index ddd45f03fa13..580ca6f8906f 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
@@ -21,11 +21,11 @@
// MODULES //
var tape = require( 'tape' );
-var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
var ones = require( '@stdlib/array/ones' );
var zeros = require( '@stdlib/array/zeros' );
var real = require( '@stdlib/complex/float64/real' );
var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
var ndarray = require( '@stdlib/ndarray/ctor' );
var everyBy = require( './../lib' );
@@ -61,14 +61,17 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray passe
tape( 'the function tests whether every element in a 1-dimensional ndarray passes a test implemented by a predicate function (accessors)', function test( t ) {
var actual;
+ var xbuf;
var x;
- x = ndarray( 'float64', toAccessorArray( zeros( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
+ xbuf = zeros( 6*2, 'float64' );
+ x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( 'float64', toAccessorArray( ones( 8, 'float64' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
+ xbuf = ones( 6*2, 'float64' );
+ x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -76,27 +79,6 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
- }
-});
-
-tape( 'the function tests whether every element in a 1-dimensional ndarray passes a test implemented by a predicate function (complex)', function test( t ) {
- var actual;
- var x;
-
- x = ndarray( 'complex128', zeros( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( 'complex128', ones( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index 044e8fa150a3..12bc7611eb9d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -21,11 +21,11 @@
// 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 real = require( '@stdlib/complex/float64/real' );
var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
var numel = require( '@stdlib/ndarray/base/numel' );
var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
@@ -76,6 +76,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -83,18 +84,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -102,7 +105,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
@@ -304,206 +307,9 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 ];
- st = [ -4, 2 ];
- o = strides2offset( sh, st );
-
- x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -511,18 +317,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -530,12 +338,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -543,18 +352,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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 ); // eslint-disable-line max-len
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -562,12 +373,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -575,18 +387,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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 );
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -594,12 +408,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -607,18 +422,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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 );
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -626,13 +443,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
+ var xbuf;
var ord;
var sh;
var st;
@@ -640,7 +458,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ dt = 'complex128';
ord = 'row-major';
bsize = blockSize( dt );
@@ -648,12 +466,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
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
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -661,13 +481,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
+ var xbuf;
var ord;
var sh;
var st;
@@ -675,7 +496,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ dt = 'complex128';
ord = 'row-major';
bsize = blockSize( dt );
@@ -683,12 +504,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
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
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -696,7 +519,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
@@ -711,7 +534,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'float64';
ord = 'column-major';
- sh = [ 4, 1 ];
+ sh = [ 1, 4 ];
st = shape2strides( sh, ord );
o = strides2offset( sh, st );
@@ -734,6 +557,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -741,18 +565,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ dt = 'complex128';
ord = 'column-major';
- sh = [ 4, 1 ];
+ sh = [ 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
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -760,7 +586,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
@@ -962,206 +788,9 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 ];
- st = [ -2, bsize*2 ];
- o = strides2offset( sh, st );
-
- x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
-tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
- t.strictEqual( actual, false, 'returns expected value' );
-
- x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
-
- actual = everyBy( [ x ], clbk );
- t.strictEqual( actual, true, 'returns expected value' );
-
- t.end();
-
- function clbk( v ) {
- return ( real( v ) !== 0.0 && imag( v ) === 0.0 );
- }
-});
-
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1169,18 +798,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1188,12 +819,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1201,18 +833,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( numel( sh ), dt ) ), sh, st, o, ord ); // eslint-disable-line max-len
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1220,12 +854,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1233,18 +868,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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 );
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1252,12 +889,13 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
var actual;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1265,18 +903,20 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ 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 );
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, false, 'returns expected value' );
- x = ndarray( dt, toAccessorArray( ones( 8, dt ) ), sh, st, o, ord );
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1284,13 +924,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1298,7 +939,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ dt = 'complex128';
ord = 'column-major';
bsize = blockSize( dt );
@@ -1306,12 +947,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
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
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1319,13 +962,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
var actual;
var bsize;
+ var xbuf;
var ord;
var sh;
var st;
@@ -1333,7 +977,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
var o;
var x;
- dt = 'float64';
+ dt = 'complex128';
ord = 'column-major';
bsize = blockSize( dt );
@@ -1341,12 +985,14 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
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
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
actual = everyBy( [ x ], clbk );
t.strictEqual( actual, true, 'returns expected value' );
@@ -1354,6 +1000,6 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
t.end();
function clbk( v ) {
- return v !== 0;
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
From 89ab24ae1ce05663caf6d7eee4a2e7d6f305ec6d Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 08:20:18 +0000
Subject: [PATCH 06/19] test: add ctx cases
---
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-by/test/test.1d.js | 118 ++++++++
.../ndarray/base/every-by/test/test.2d.js | 280 ++++++++++++++++++
2 files changed, 398 insertions(+)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
index 580ca6f8906f..eff9f74e4b13 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.1d.js
@@ -82,3 +82,121 @@ tape( 'the function tests whether every element in a 1-dimensional ndarray passe
return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
}
});
+
+tape( 'the function supports specifying the callback execution context', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var x;
+
+ x = new ndarray( 'float64', ones( 8, 'float64'), [ 4 ], [ 2 ], 0, 'row-major' );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0 ],
+ [ 1 ],
+ [ 2 ],
+ [ 3 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var x;
+
+ xbuf = ones( 6*2, 'float64' );
+ x = ndarray( 'complex128', new Complex128Array( xbuf ), [ 4 ], [ 1 ], 1, 'row-major' );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0 ],
+ [ 1 ],
+ [ 2 ],
+ [ 3 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index 12bc7611eb9d..212e9df1db3a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -109,6 +109,146 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
+tape( 'the function supports specifying the callback execution context', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0 ],
+ [ 0, 1 ],
+ [ 1, 0 ],
+ [ 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0 ],
+ [ 0, 1 ],
+ [ 1, 0 ],
+ [ 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous)', function test( t ) {
var actual;
var ord;
@@ -590,6 +730,146 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
+tape( 'the function supports specifying the callback execution context', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0 ],
+ [ 1, 0 ],
+ [ 0, 1 ],
+ [ 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0 ],
+ [ 1, 0 ],
+ [ 0, 1 ],
+ [ 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
tape( 'the function tests whether every element in a 2-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous)', function test( t ) {
var actual;
var ord;
From d21d386a125e4fa728bf73db3294c634f9d47568 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Mon, 16 Jun 2025 08:24:43 +0000
Subject: [PATCH 07/19] fix: col 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
---
---
.../@stdlib/ndarray/base/every-by/test/test.2d.js | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index 212e9df1db3a..6e78fbadb4a6 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -565,7 +565,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'row-major';
sh = [ 2, 2 ];
- st = [ 4, -1 ];
+ st = [ -1, 4 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
@@ -1186,7 +1186,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'column-major';
sh = [ 2, 2 ];
- st = [ 4, -1 ];
+ st = [ -1, 4 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
From 3596e4b83c5fa0da083b25f07b1f3a5f6cf984a9 Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Mon, 23 Jun 2025 22:07:19 +0500
Subject: [PATCH 08/19] chore: cleanup
---
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-by/test/test.2d.js | 24 +++++++++----------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index 6e78fbadb4a6..825261064b76 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -109,7 +109,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
-tape( 'the function supports specifying the callback execution context', function test( t ) {
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
var expected;
var indices;
var values;
@@ -178,7 +178,7 @@ tape( 'the function supports specifying the callback execution context', functio
}
});
-tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) {
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
var expected;
var indices;
var values;
@@ -325,7 +325,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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 );
@@ -357,7 +357,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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 );
@@ -530,7 +530,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'row-major';
sh = [ 2, 2 ];
- st = [ 4, 1 ];
+ st = [ 4, 2 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
@@ -565,7 +565,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'row-major';
sh = [ 2, 2 ];
- st = [ -1, 4 ];
+ st = [ -2, 4 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
@@ -730,7 +730,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
}
});
-tape( 'the function supports specifying the callback execution context', function test( t ) {
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
var expected;
var indices;
var values;
@@ -799,7 +799,7 @@ tape( 'the function supports specifying the callback execution context', functio
}
});
-tape( 'the function supports specifying the callback execution context (accessors)', function test( t ) {
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
var expected;
var indices;
var values;
@@ -946,7 +946,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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 );
@@ -978,7 +978,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
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 );
@@ -1151,7 +1151,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'column-major';
sh = [ 2, 2 ];
- st = [ 1, 4 ];
+ st = [ 2, 4 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
@@ -1186,7 +1186,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'column-major';
sh = [ 2, 2 ];
- st = [ -1, 4 ];
+ st = [ -2, 4 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );
From 79b5876d874892d2bea2f18dca9841394b3f37ea Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Mon, 23 Jun 2025 22:29:06 +0500
Subject: [PATCH 09/19] test: 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-by/test/test.3d.js | 1479 +++++++++++++++++
1 file changed, 1479 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
new file mode 100644
index 000000000000..53981acbfb70
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
@@ -0,0 +1,1479 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0 ],
+ [ 0, 0, 1 ],
+ [ 0, 1, 0 ],
+ [ 0, 1, 1 ],
+ [ 1, 0, 0 ],
+ [ 1, 0, 1 ],
+ [ 1, 1, 0 ],
+ [ 1, 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0 ],
+ [ 0, 0, 1 ],
+ [ 0, 1, 0 ],
+ [ 0, 1, 1 ],
+ [ 1, 0, 0 ],
+ [ 1, 0, 1 ],
+ [ 1, 1, 0 ],
+ [ 1, 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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, 2 ];
+ st = [ -2, -2, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = [ 4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = [ 4, -4, -2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*4, -2, -2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*4, -bsize*4, -2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 2, 2 ];
+ st = [ -2, -2, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2 ];
+ st = [ 4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2 ];
+ st = [ -4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*4, -2, -2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*4, -bsize*4, -2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0 ],
+ [ 1, 0, 0 ],
+ [ 0, 1, 0 ],
+ [ 1, 1, 0 ],
+ [ 0, 0, 1 ],
+ [ 1, 0, 1 ],
+ [ 0, 1, 1 ],
+ [ 1, 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0 ],
+ [ 1, 0, 0 ],
+ [ 0, 1, 0 ],
+ [ 1, 1, 0 ],
+ [ 0, 0, 1 ],
+ [ 1, 0, 1 ],
+ [ 0, 1, 1 ],
+ [ 1, 1, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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, 2 ];
+ st = [ -1, 2, -4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = [ 2, 2, 4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = [ -2, 2, 4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, 4, bsize*8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 2, 2 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2 ];
+ st = [ 2, 4, 4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2 ];
+ st = [ -2, 4, 4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ -2, bsize*4, bsize*4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, -4, bsize*4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 3-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From 9d1a661cbf941887a66f24923d21d41b520cde49 Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Mon, 23 Jun 2025 23:49:06 +0500
Subject: [PATCH 10/19] test: 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-by/test/test.3d.js | 2 +-
.../ndarray/base/every-by/test/test.4d.js | 1577 +++++++++++++++++
2 files changed, 1578 insertions(+), 1 deletion(-)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
index 53981acbfb70..1456ca588b10 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.3d.js
@@ -1418,7 +1418,7 @@ tape( 'the function tests whether every element in a 3-dimensional ndarray passe
bsize = blockSize( dt );
sh = [ 2, bsize*2, 1 ];
- st = [ 2, -4, bsize*4 ];
+ st = [ 2, -4, bsize*8 ];
o = strides2offset( sh, st );
xbuf = zeros( numel( sh )*4, 'float64' );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
new file mode 100644
index 000000000000..08c03662521e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
@@ -0,0 +1,1577 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0 ],
+ [ 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0 ],
+ [ 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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, -4, -2, -2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*4, -2, -2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*4, -bsize*4, -2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1 ];
+ st = [ -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1 ];
+ st = [ 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1 ];
+ st = [ -4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*4, -2, -2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*4, -bsize*4, -2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0 ],
+ [ 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0 ],
+ [ 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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];
+ st = [ -1, 2, -2, 4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = [ 2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 = [ -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( 8, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, 4, bsize*8, bsize*8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, 4, 4, bsize*8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, 4, 4, 4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 2, 4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1 ];
+ st = [ 2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1 ];
+ st = [ -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 = [ 2, -4, bsize*8, bsize*8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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*8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 4-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, -4, 4, 4 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From 7301121f570c53e120e2b2262ff02ffd0bf3b281 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 05:18:18 +0000
Subject: [PATCH 11/19] test: 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-by/test/test.4d.js | 2 +-
.../ndarray/base/every-by/test/test.5d.js | 1771 +++++++++++++++++
2 files changed, 1772 insertions(+), 1 deletion(-)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.5d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
index 08c03662521e..09322791b663 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.4d.js
@@ -1059,7 +1059,7 @@ tape( 'the function tests whether every element in a 4-dimensional ndarray passe
dt = 'float64';
ord = 'column-major';
- sh = [ 2, 1, 2, 1];
+ sh = [ 2, 1, 2, 1 ];
st = [ -1, 2, -2, 4 ];
o = strides2offset( sh, st );
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.5d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.5d.js
new file mode 100644
index 000000000000..2dc85705bbf5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.5d.js
@@ -0,0 +1,1771 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1 ],
+ [ 0, 0, 1, 0, 0 ],
+ [ 0, 0, 1, 0, 1 ],
+ [ 1, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 1 ],
+ [ 1, 0, 1, 0, 0 ],
+ [ 1, 0, 1, 0, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1 ],
+ [ 0, 0, 1, 0, 0 ],
+ [ 0, 0, 1, 0, 1 ],
+ [ 1, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 1 ],
+ [ 1, 0, 1, 0, 0 ],
+ [ 1, 0, 1, 0, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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, 2 ];
+ st = [ -4, -4, -2, -2, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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, 8, 4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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, -8, -4, -4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 8, 4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 8, 4, 4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ 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, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0 ],
+ [ 1, 0, 1, 0, 0 ],
+ [ 0, 0, 0, 0, 1 ],
+ [ 1, 0, 0, 0, 1 ],
+ [ 0, 0, 1, 0, 1 ],
+ [ 1, 0, 1, 0, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ 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 );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0 ],
+ [ 1, 0, 1, 0, 0 ],
+ [ 0, 0, 0, 0, 1 ],
+ [ 1, 0, 0, 0, 1 ],
+ [ 0, 0, 1, 0, 1 ],
+ [ 1, 0, 1, 0, 1 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -1, -2, 2, -4, 4 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = [ 2, 4, 4, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = [ -2, -4, 4, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2 ];
+ st = [ 2, 4, 4, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2 ];
+ st = [ 2, -4, 4, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 5-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From 2e2fb15f192b08229ae9359453030fb03650717d Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 05:34:08 +0000
Subject: [PATCH 12/19] test: 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-by/test/test.6d.js | 1917 +++++++++++++++++
1 file changed, 1917 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.6d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.6d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.6d.js
new file mode 100644
index 000000000000..1cacb06ca81b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.6d.js
@@ -0,0 +1,1917 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0 ],
+ [ 1, 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 1, 0 ],
+ [ 1, 0, 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0 ],
+ [ 1, 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 1, 0 ],
+ [ 1, 0, 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1 ];
+ st = [ -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -4, -4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0 ],
+ [ 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0 ],
+ [ 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0 ],
+ [ 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0 ],
+ [ 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0 ],
+ [ 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0 ],
+ [ 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ 2, -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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, -4, 4, 4, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ -2, -4, 4, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ -2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, 4, -4, bsize*8, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ 2, 4, -4, 4, bsize*8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ 2, 4, -4, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 6-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From f38d0dd1ddb9bb184712e3adcaff8decb3ce7182 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 05:50:26 +0000
Subject: [PATCH 13/19] test: 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-by/test/test.7d.js | 2063 +++++++++++++++++
1 file changed, 2063 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.7d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.7d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.7d.js
new file mode 100644
index 000000000000..41e8fa300930
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.7d.js
@@ -0,0 +1,2063 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -4, -4, 4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -16, -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ -2, -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (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, bsize*2 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ -2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ 2, 4, -4, bsize*8, bsize*8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ 2, 4, -4, 4, bsize*8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ 2, 4, -4, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 7-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, bsize*2 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From fcf73d596f077e06fc2d6435ab287c47a28f0340 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 06:11:16 +0000
Subject: [PATCH 14/19] test: 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-by/test/test.8d.js | 2209 +++++++++++++++++
1 file changed, 2209 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.8d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.8d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.8d.js
new file mode 100644
index 000000000000..96c39b28a032
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.8d.js
@@ -0,0 +1,2209 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, bsize*4, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -16, -16, -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, bsize*4, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -2, -2, -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ 2, bsize*4, -bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ 2, -4, 4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ -2, -4, 4, 4, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, bsize*2, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ -2, -bsize*4, bsize*4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ 2, -4, bsize*8, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ 2, 4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ 2, 4, -4, 4, bsize*8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, bsize*2, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 8-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From e7c5affa8135ddab98f20269b4adcbf97d505896 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 06:54:29 +0000
Subject: [PATCH 15/19] test: 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-by/test/test.9d.js | 2435 +++++++++++++++++
1 file changed, 2435 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.9d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.9d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.9d.js
new file mode 100644
index 000000000000..91043026c7b6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.9d.js
@@ -0,0 +1,2435 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, bsize*2 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -16, -16, -16, -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1, 1, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, bsize*2 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -2, -2, -2, -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [
+ 2,
+ bsize*4,
+ -bsize*4,
+ bsize*8,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ -4,
+ bsize*8,
+ bsize*8,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ 2, -4, 4, bsize*8, bsize*8, 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ -2, -4, 4, 4, bsize*8, 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, bsize*2, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, bsize*2 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [
+ -2,
+ -bsize*4,
+ bsize*4,
+ bsize*8,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [
+ 2,
+ -4,
+ bsize*8,
+ bsize*8,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ 2, 4, -4, bsize*8, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ 2, 4, -4, 4, bsize*8, bsize*16, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, bsize*2, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 9-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, bsize*2 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From 2d554192f38b0da2a3ff5ed41a649913c8cbe202 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 07:11:21 +0000
Subject: [PATCH 16/19] test: 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-by/test/test.10d.js | 2655 +++++++++++++++++
1 file changed, 2655 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.10d.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.10d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.10d.js
new file mode 100644
index 000000000000..6535ee9254ec
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.10d.js
@@ -0,0 +1,2655 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2, 1, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, bsize*2, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, bsize*2 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -16, -16, -16, -16, -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ -8, 8, 4, 4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 2, 1, 1, 1, 1, 1, 1 ];
+ st = [ bsize*8, -4, -4, 2, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -4, 4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, 2, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, 2, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, 2, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1 ];
+ st = [ bsize*8, -bsize*8, -bsize*4, bsize*4, bsize*4, bsize*4, 2, 2, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2, 1, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, bsize*2, 1 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, bsize*2 ];
+ st = [
+ bsize*8,
+ -bsize*8,
+ -bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ bsize*4,
+ 2
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -2, -2, -2, -2, -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ bsize*4,
+ -bsize*4,
+ bsize*8,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ -4,
+ bsize*8,
+ bsize*8,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ -4,
+ 4,
+ bsize*8,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [
+ -2,
+ -4,
+ 4,
+ 4,
+ bsize*8,
+ 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 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 = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, bsize*2, 1, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, bsize*2, 1, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, bsize*2, 1 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (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, 1, 1, 1, bsize*2 ];
+ st = [ -2, -4, 4, 8, 8, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*2, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [
+ -2,
+ -bsize*4,
+ bsize*4,
+ bsize*8,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ -4,
+ bsize*8,
+ bsize*8,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ 4,
+ -4,
+ bsize*8,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1, 1 ];
+ st = [
+ 2,
+ 4,
+ -4,
+ 4,
+ bsize*8,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16,
+ bsize*16
+ ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, bsize*16, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, bsize*2, 1, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, bsize*16, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, bsize*2, 1, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8, bsize*16, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, bsize*2, 1 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8, 8, bsize*16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a 10-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+ var actual;
+ var bsize;
+ var xbuf;
+ 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, 1, 1, 1, bsize*2 ];
+ st = [ 2, 4, -4, 8, 8, 8, 8, 8, 8, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From e8dcd37cb893a6b0c062a72a6b2ee50b4790e2a9 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 07:40:12 +0000
Subject: [PATCH 17/19] test: 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-by/test/test.nd.js | 1040 +++++++++++++++++
1 file changed, 1040 insertions(+)
create mode 100644 lib/node_modules/@stdlib/ndarray/base/every-by/test/test.nd.js
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.nd.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.nd.js
new file mode 100644
index 000000000000..5c67285d9cf5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.nd.js
@@ -0,0 +1,1040 @@
+/**
+* @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 zeros = require( '@stdlib/array/zeros' );
+var ones = require( '@stdlib/array/ones' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+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 everyBy = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof everyBy, 'function', 'main export is a function');
+ t.end();
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (row-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (row-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 16, 8, -8, -4, -4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (row-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -8, -8, -8, -8, -8, -4, -4, -2, -2, -1, -1 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 16, 16, 16, 16, 16, 8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'row-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -16, -16, -16, -16, -16, -8, 8, 4, 4, 2, 2 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (column-major, singleton dimensions, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ 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, 1, 1, 4 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'float64';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0,
+ 1.0
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( v );
+ indices.push( idx );
+ arrays.push( arr );
+ return v !== 0.0;
+ }
+});
+
+tape( 'the function supports specifying the callback execution context (column-major, contiguous, accessors)', function test( t ) {
+ var expected;
+ var indices;
+ var values;
+ var arrays;
+ var actual;
+ var xbuf;
+ var ctx;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ indices = [];
+ values = [];
+ arrays = [];
+
+ ctx = {
+ 'count': 0
+ };
+ actual = everyBy( [ x ], clbk, ctx );
+
+ t.strictEqual( actual, true, 'returns expected value' );
+ t.strictEqual( ctx.count, 8, 'returns expected value' );
+
+ expected = [
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ],
+ [ 1.0, 1.0 ]
+ ];
+ t.deepEqual( values, expected, 'returns expected value' );
+
+ expected = [
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 ],
+ [ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0 ]
+ ];
+ t.deepEqual( indices, expected, 'returns expected value' );
+
+ expected = [
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x,
+ x
+ ];
+ t.deepEqual( arrays, expected, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v, idx, arr ) {
+ this.count += 1; // eslint-disable-line no-invalid-this
+ values.push( [ real( v ), imag( v ) ] );
+ indices.push( idx );
+ arrays.push( arr );
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -1, -1, -2, -2, 4, -4, 8 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh ), dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (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, 1, 2, 1, 2, 1 ];
+ st = [ -2, -2, -2, -2, -2, -2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ x = ndarray( dt, zeros( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ x = ndarray( dt, ones( numel( sh )*4, dt ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0;
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = shape2strides( sh, ord );
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (column-major, contiguous, negative strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ -1, -1, -1, -1, -1, -1, -2, -2, 4, 4, 8 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( numel( sh )*2, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, 2, 4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
+
+tape( 'the function tests whether every element in a n-dimensional ndarray passes a test implemented by a predicate function (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+ var actual;
+ var xbuf;
+ var ord;
+ var sh;
+ var st;
+ var dt;
+ var o;
+ var x;
+
+ dt = 'complex128';
+ ord = 'column-major';
+ sh = [ 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1 ];
+ st = [ 2, 2, 2, 2, 2, 2, -4, 4, 8, 8, 16 ];
+ o = strides2offset( sh, st );
+
+ xbuf = zeros( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, false, 'returns expected value' );
+
+ xbuf = ones( 8*4, 'float64' );
+ x = ndarray( dt, new Complex128Array( xbuf ), sh, st, o, ord );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return ( real( v ) !== 0.0 && imag( v ) !== 0.0 );
+ }
+});
From a1d7985f0b9b1ea208a09b2694a851743f0dfe87 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 07:45:52 +0000
Subject: [PATCH 18/19] test: add empty ndarray 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-by/test/test.js | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.js
index bc474f3ac57c..886a3653a0f0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.js
@@ -21,6 +21,8 @@
// MODULES //
var tape = require( 'tape' );
+var ones = require( '@stdlib/array/ones' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
var everyBy = require( './../lib' );
@@ -31,3 +33,19 @@ tape( 'main export is a function', function test( t ) {
t.strictEqual( typeof everyBy, 'function', 'main export is a function' );
t.end();
});
+
+tape( 'the function returns `true` if provided an empty input ndarray', function test( t ) {
+ var actual;
+ var x;
+
+ x = ndarray( 'float64', ones( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+ actual = everyBy( [ x ], clbk );
+ t.strictEqual( actual, true, 'returns expected value' );
+
+ t.end();
+
+ function clbk( v ) {
+ return v !== 0.0;
+ }
+});
From 69664ded60af12971004583b9363e24983bcc254 Mon Sep 17 00:00:00 2001
From: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
Date: Tue, 24 Jun 2025 15:26:10 +0500
Subject: [PATCH 19/19] fix: incorrect strides
Signed-off-by: Muhammad Haris <101793258+headlessNode@users.noreply.github.com>
---
lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
index 825261064b76..017d3908ccc7 100644
--- a/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/every-by/test/test.2d.js
@@ -565,7 +565,7 @@ tape( 'the function tests whether every element in a 2-dimensional ndarray passe
dt = 'complex128';
ord = 'row-major';
sh = [ 2, 2 ];
- st = [ -2, 4 ];
+ st = [ -4, -2 ];
o = strides2offset( sh, st );
xbuf = zeros( 8*2, 'float64' );