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 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 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 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' );